{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.312948\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -2.525690 analytic: -2.525690, relative error: 2.519787e-08\n",
      "numerical: -0.693769 analytic: -0.693769, relative error: 2.861776e-08\n",
      "numerical: 0.420918 analytic: 0.420918, relative error: 4.751714e-08\n",
      "numerical: 2.793258 analytic: 2.793258, relative error: 1.029771e-08\n",
      "numerical: 2.713899 analytic: 2.713899, relative error: 3.148164e-09\n",
      "numerical: -2.234157 analytic: -2.234157, relative error: 2.285559e-09\n",
      "numerical: -1.592954 analytic: -1.592954, relative error: 1.221460e-09\n",
      "numerical: 1.150786 analytic: 1.150786, relative error: 3.733113e-08\n",
      "numerical: 0.240902 analytic: 0.240902, relative error: 3.640058e-07\n",
      "numerical: -5.331286 analytic: -5.331286, relative error: 2.212013e-09\n",
      "numerical: -0.112263 analytic: -0.112263, relative error: 1.569922e-07\n",
      "numerical: 2.030583 analytic: 2.030583, relative error: 3.794514e-09\n",
      "numerical: 1.496551 analytic: 1.496551, relative error: 7.773800e-09\n",
      "numerical: 3.890925 analytic: 3.890925, relative error: 2.193669e-09\n",
      "numerical: -0.388712 analytic: -0.388712, relative error: 8.311550e-08\n",
      "numerical: -0.834008 analytic: -0.834008, relative error: 2.356894e-08\n",
      "numerical: -0.567360 analytic: -0.567360, relative error: 9.194376e-08\n",
      "numerical: 1.427417 analytic: 1.427417, relative error: 1.037430e-08\n",
      "numerical: 0.332776 analytic: 0.332776, relative error: 1.129248e-08\n",
      "numerical: -3.640166 analytic: -3.640166, relative error: 1.245428e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.312948e+00 computed in 0.134637s\n",
      "vectorized loss: 2.312948e+00 computed in 0.006989s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 391.247721\n",
      "iteration 100 / 1500: loss 236.613335\n",
      "iteration 200 / 1500: loss 143.688781\n",
      "iteration 300 / 1500: loss 87.712711\n",
      "iteration 400 / 1500: loss 53.808803\n",
      "iteration 500 / 1500: loss 33.382572\n",
      "iteration 600 / 1500: loss 20.986718\n",
      "iteration 700 / 1500: loss 13.486921\n",
      "iteration 800 / 1500: loss 8.970357\n",
      "iteration 900 / 1500: loss 6.238379\n",
      "iteration 1000 / 1500: loss 4.537048\n",
      "iteration 1100 / 1500: loss 3.515680\n",
      "iteration 1200 / 1500: loss 2.986909\n",
      "iteration 1300 / 1500: loss 2.609098\n",
      "iteration 1400 / 1500: loss 2.395682\n",
      "iteration 0 / 1500: loss 766.260735\n",
      "iteration 100 / 1500: loss 281.243098\n",
      "iteration 200 / 1500: loss 104.313989\n",
      "iteration 300 / 1500: loss 39.558914\n",
      "iteration 400 / 1500: loss 15.721780\n",
      "iteration 500 / 1500: loss 7.074585\n",
      "iteration 600 / 1500: loss 3.963659\n",
      "iteration 700 / 1500: loss 2.749118\n",
      "iteration 800 / 1500: loss 2.337807\n",
      "iteration 900 / 1500: loss 2.139103\n",
      "iteration 1000 / 1500: loss 2.140160\n",
      "iteration 1100 / 1500: loss 2.117046\n",
      "iteration 1200 / 1500: loss 2.048563\n",
      "iteration 1300 / 1500: loss 2.050835\n",
      "iteration 1400 / 1500: loss 2.120177\n",
      "iteration 0 / 1500: loss 394.025779\n",
      "iteration 100 / 1500: loss 33.248960\n",
      "iteration 200 / 1500: loss 4.582421\n",
      "iteration 300 / 1500: loss 2.164198\n",
      "iteration 400 / 1500: loss 2.059907\n",
      "iteration 500 / 1500: loss 2.111191\n",
      "iteration 600 / 1500: loss 2.076269\n",
      "iteration 700 / 1500: loss 2.049524\n",
      "iteration 800 / 1500: loss 2.051589\n",
      "iteration 900 / 1500: loss 2.114340\n",
      "iteration 1000 / 1500: loss 1.999856\n",
      "iteration 1100 / 1500: loss 2.012740\n",
      "iteration 1200 / 1500: loss 2.021915\n",
      "iteration 1300 / 1500: loss 2.029928\n",
      "iteration 1400 / 1500: loss 2.036602\n",
      "iteration 0 / 1500: loss 768.871674\n",
      "iteration 100 / 1500: loss 6.843029\n",
      "iteration 200 / 1500: loss 2.087827\n",
      "iteration 300 / 1500: loss 2.048399\n",
      "iteration 400 / 1500: loss 2.085914\n",
      "iteration 500 / 1500: loss 2.099765\n",
      "iteration 600 / 1500: loss 2.113360\n",
      "iteration 700 / 1500: loss 2.065450\n",
      "iteration 800 / 1500: loss 2.057058\n",
      "iteration 900 / 1500: loss 2.130555\n",
      "iteration 1000 / 1500: loss 2.079273\n",
      "iteration 1100 / 1500: loss 2.104998\n",
      "iteration 1200 / 1500: loss 2.090225\n",
      "iteration 1300 / 1500: loss 2.053163\n",
      "iteration 1400 / 1500: loss 2.128080\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.350673 val accuracy: 0.360000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.326959 val accuracy: 0.346000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.346265 val accuracy: 0.359000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.325735 val accuracy: 0.334000\n",
      "best validation accuracy achieved during cross-validation: 0.360000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        mySoftmax = Softmax()\n",
    "        loss_hist = mySoftmax.train(X_train, y_train, learning_rate=lr, reg=rs,\n",
    "                      num_iters=1500, verbose=True)\n",
    "        y_train_pred = mySoftmax.predict(X_train)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = mySoftmax.predict(X_val)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        \n",
    "        results[(lr, rs)] = (train_accuracy, val_accuracy)\n",
    "        \n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_softmax = mySoftmax\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.364000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAADfCAYAAADvJIiwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvXd43Md17/39AVh0LHrvvZMAC9g7KZIqVLcsy5JcYzt2chO/yc2bchPfJ05yc53m2HGVbdlWs4rVKJEiJbGDBSSIQhC9914WfQHs+8dndC+jSDLhQpl+9zyPHhG7+5vfzJkzc76nzBnL5XLJTW5yk5vcdPORx4fdATe5yU1uctMvR+4N3E1ucpObblJyb+BucpOb3HSTknsDd5Ob3OSmm5TcG7ib3OQmN92k5N7A3eQmN7npJqWbdgO3LGu7ZVldH3Y/3PTbTZZltVmWtfs9Pt9iWVb9Mtt63LKsr/76euem30a6meb5pt3A3eSmX4VcLtcpl8uV/WH342ak91OKbrrx5N7A3fRfyLIsrw+7Dx8m/f99/G769dNvSqZ+6zdwo+3/3LKsq5ZljVqW9SPLsnzf43f/r2VZzZZlOcxv777mu09YlnXasqx/Mm20Wpa1/5rvgy3L+oFlWb2WZXVblvVVy7I8b9QYf91kWVaiZVk/tyxr0LKsYcuyvmlZVrplWW+bv4csy3rSsqyQa55psyzrzyzLqpI09Tu2ia19t/y82wX3XuO3LKvYsqxyI1M/k/Rf5O5mp+XKimVZP5WUJOlVy7ImLcv67x/uCH51+qB5tizrdsuyKizLGrMsq9SyrBXXfBdnWdYLhnetlmX94TXffcWyrOcty3rCsqwJSZ/4jXTe5XL9Vv8nqU3SFUmJksIknZH0VUnbJXVd87v7JcUJpfSApClJsea7T0hySvqsJE9JX5DUI8ky378k6buSAiRFSbog6XMf9th/SX55SqqU9K9mPL6SNkvKkLRHko+kSEknJf3bu/hcYfjs92GP40OQn/80fknektol/bEkm6T7jAx99cMe02+JrOz+sPv/a+LB+86zpFWSBiStM7x61Izdx+wzlyT9tWkjTVKLpL2m3a+Ydu4yv/2NrKkPnYHXweA2SZ+/5u9bJTW/ewG+x3MVku40//6EpKZrvvOX5JIUIyla0ty1DJb0oKRjH/bYf0l+bZA0KMnrF/zuLkmX38XnT33Y/f+w5Ofd45e0VdcoefNZ6e/YBv6ryMrvygb+vvMs6duS/vZdv6+XtM1s6h3v+u7PJf3I/Psrkk7+pvt/s5jJndf8u10g7f9ElmU9IunLklLMR4GSIq75Sd87/3C5XNOWZb3zmzCheXvNZxIa89p33kyUKKnd5XItXPuhZVlRkv5d0hZJQWKMo+969mYd8y+iXyg/7/G7OEndLrMar3n2d4l+FVn5XaEPmudkSY9alvUH13znbZ5ZlBRnWdbYNd95Sjp1zd+/8fX0W+8DN5R4zb+ThMb8P2RZVrKk70v6kqRwl8sVIsxmS7+YOgUCj3C5XCHmP7vL5cr/9XT9hlOnpKT38GH/g7A6VrhcLrukj+u/8ud3tTTlB8rPNXTt+HslxVvXaHXz7O8S/bKy8rskJx80z52S/u6afSHE5XL5u1yup813re/6Lsjlct16TTu/cT7dLBv4Fy3LSrAsK0zSX0j62bu+DxDMGpQky7I+Kangehp2uVy9ko5I+mfLsuyWZXmYIM62X1/3byhdEEL5vyzLCjABu00CSU1KGrMsK17Sn36YnbzB9Ivk573orKQFSX9oApr3SCr5TXbyQ6BfVlb6hc/3d4E+aJ6/L+nzlmWts6AAy7JusywrSPBuwgS+/SzL8rQsq8CyrLU3svM3ywb+lNhkW8x//ynJ3uVyXZX0z2Iy+iUVimDV9dIjwjS6KkzF5yXF/sq9/hDI5XItSrpDBKI6JHWJoO7/FEGZcUmvSfr5h9XHD4E+UH7ei1wu17yke0T8ZFTw8HeKZ7+CrPyDpL8ymRl/cuN6/OunD5pnl8t1USQ+fNN812R+dy3viiS1ShqS9Jik4BvZf+s/u35++8iyrDZJn3G5XG9+2H1xk5vc5KbfJrpZELib3OQmN7npXeTewN3kJje56Sal33oXipvc5CY3uem9yY3A3eQmN7npJqUbepDns3/1RZckJWzm78Cr96rZkSFJiu/8Z0lS22yKJKkpN0iS9HBflprS3pYkDbTGS5K8wsYlSRnFmZKk+rmLkiRP+5QCv8Vn69OdkqQf9zRJkmIjySr02NKh/VN+kqRzjeskSTULsMHmS/mTzTueluMVklAcdm9JUpl9QpJ0V3WMJGkxPVCSNDUXpKUsSoqE9ZVKkv7wz/76evLPJUlPfvJjLkl6JsFfkrTOc1QrbR+hX9srJEml7aQx7+uiREOzZ4+2j81LkrznCyVJLTG1kqSYIfrSOMlYpu0lGl99WZJUONkrSWrz5exByNOzkqT4B0c1e4bSMOUJxyRJ2ZeSJUn1OxmK96KPgutoM33NcUlSq+PjkqSEk9X0a+uSJMkjKFYb2y5JkgLfZD42HLt+nvzr//iMS5KqYpANH/9uZVjdkqTunkHaDX5IkrR++hlJUnVgjLpaSQCwzQ9IkroGmbu0olDGYJuWJI20DWpwLZbnQ8EBkiT/w8zr8xs4e+HX7tKuyEl4cDZLkhS+9aokqbGfMdm6JjVRQTsRoeGSJMcO3j09zjyMBSM3C6n+shtZXNkOH7/wj6eumyeSdP/HPuWSpEe30dfqV7p0PJJ18okUZPj4EHxa3Yl8nPIJUOSdpDVH28kDSH9skyRpYCXrKKiUjMALMZUqHmOs9mBk7VgzMrK3CHk/VNigh/+DEjLHHjggSSq8xFwfLZiTJC3VJan4Yebp7RcXJUl/krBRkvSE1xFJkvcca1mpM3J+l3NE60qYv4989xvXzZd//qN9Lknq6GNOssIbVRZEuZKSOiMHm0ckSZZXpCTJdyBeLdXMy9w2xhI2tV2S5PALkyQ5Xd/h82abGnbA7xJf5KFfzN/iCHM+HZimA1UzkqTaMOTpQg+8ze6wSZICk73Uk1EjScp8mXdaWQ9IkobCOTd0IpLv8wenlJW/SpIU/gxy9IXnvvKePHEjcDe5yU1uuknphiLwdb5fkiQ1d3PadOhslfrWon3C/UCAG3NAAC0ONHVZ7aJmbWi1oBz+77Mf7TlzFuTtt8iJ+YDTO9U2AWIYsvVLkiK3fkySNH+2RZJUNJ6vIxOglN4gtKZ9GA1dtwhiyyq7W1Xx/KZgdo0kKXekWZL0+u4ESdId5W9JkqoDwuXqR9u6Ls4vmydjoVgD+y2HJOlq9w75bXpZkuR8G43/xT4Q+IVe0nHvCntUPhaa/eeL5fQzA9Qx1gkvquPPSZI+Mdeg9hOgyh4vflMs+l4Tu0GSNPP4zzW2Guth9Wy6JKk/AM2/OqpSklRbOaMtHhxOragBOVyJG5IkdcWBoNaGcsDx7FteGran0Hbq4LJ5ktQOapv3o9/DPsHqqGAe/Vf+hSQp90KZJOl8MRZI9oDUeGGLJCnjI4xl2I68BDiZSw3BM99VDu2pA93/dFuHJGndFNaDf8dq/n/HMVVfyJEkLc4iF6dG19NOB0h+IO9BxUycliQFp7wkSQqv3i5JOroArz4eDzrtm17QoA/8PhqALH5hmXzZF5sqSapuR177s5OVvgrrovI5rKvYojxJ0kgE62DDeKOuvsl6cQwjy413g1bjnFip04m093bYRvWmDkuStp9ulCR9rMAuSXrqHmR779cidOh2rEW/JmRvfhcINa8ayy4zaEjzVchhRCS8qhRj3jcCsmx1gfrr5w8pwwd5ag16ZZkckbxiiyRJC9VYN813eir156yll9ayLiP6meOQKEDs6ECNulbT51ti90mScrrYS342yrPbHFigXmsi5NMIMu7NQx5WtzJOr0HWyjPTvWrwREaORGKpPJTbKkka38A7u8tc2jpJgdS31/1QkpTvRHYSfLBGImt5dnpyVB1N53ku9IMPhLsRuJvc5CY33aR0QxF43WXQWGcPiDIz2aF1LfiDLoThr2ocQwv5GJ/Z3LZyBbeC7ApmdkmShr6DNu/pRftG5eCvq4r1kjOGtt9w0k76DP7Z2mh8hS+GRGpdPTdpLQSgHedPgxJC/4M+FJxoVEwmJ2K7j/1UkuR0gFpWh4NWLs/gU++evaqdvqDA8cjty+aJIwKLY1cKB0cDPAfVvQQCzbkKYnsmiDpcucFo+Vfjx2SfAlWMhFyRJN29BAJ7KRy/3LYUUMLZ7gb5hIAcIprrJEkvrEWrB1/Eypn6Uokcz4DGvP+cfkV844QkyaPhdknSo42zemU9fKvZCDrP+iHI7iODILuvp4Bi7rrfX1d6Qc+zk/D9wDJ48noE853QCTKzfN5WYh7WUncTvF4SyDMmks9P1Xhr6K7nJEnHIkF/O6doZ3rMR5LkmgeveDbepiU7VmBmK/GG0BL8232DoLaZZ6YVPIHF0vVxrLnAQ6DSwpXMz4XFlzTpuVKSlJgODyqyQGV/0gA6re8HGU76FKnfFwS9yfHLZX51mb4Nl9Av35ElxZ1okCQFzGENefpQc6rOARJPuLIo50dBla5vg3obWomXFE4zj+U+IOofeVxUiw1kOpYD8j6fyfyp3cjbylRFTNNe0hCIst3zW5KkCE+CW2/UN8lvN2vyjhHkYLrDoP1ZYksz0ViIA72x6jaxnti25Z9Cf3IAKzXpHmTaPj2lgnzW/qoI1vegxTvD57F2vYayNBfJWvKtwuJonsNiidhOe7anoyVJjYvxairD550XgMycPPdRSVL+2qOSpK0BB1S90CZJKk5m/xn+EeN2FcG/iKg+9YxhxY/EISv/VoNV8/k8fPObAkDtad1xetHOPESO1Hzg+G/oBt71MYSg5BybTc9AkY77Yn4XEDvQYAcDzzZm6pJXkFLE5vktO8HMlcbMnQ1hQcRsxkyNOvuavFL2SpJsggFpAQjigKmlZtUeU0EaZtx8Gyb22J/lSpKiv8eGdjrBW5GdbNAL4fQnOnOnJKl1D7+pOAjrcj281RuAkgife78id+9P3r6Y9Ud/iMJqzfJQv9i4UzeaoKAPi3GoGiZ1NY3o9o/Ct8ZxBPdb32DjViSb6FQKm1/n24/pzgwUQHskiyrxFZ69kEAQ9yujnrrkQHj8v4ogp+x4UJJ0ycbYBnIjlbnAc14m6FQyhBujqgTm+kxM8fdihBaH4P/g4NyyeeIXx6bcnI3CeKh7QXWevMN3rE2SVBeHgopZYMNcCAzV/gkWQswAi7PCjgxVrWDTf6SGG9S+FTGjqFmUT8gs4z5mBOSRkSpJUunM3arPYsHlH2dcrUkogKAa3C9+CfUKXo/sjfqhiDv6UajRDuZwLplF6vSKlN9u+HXZBBGXS4HzyFxOv5G3M136aTyb0x2xjO3ELKZ31CL9CM60KecM/Q1IYbOaEc+3eqO8POvZ/M8ltss5yDjyxgh8dwXukCRtmMDVOStveUUAxGaDADd+NWxIlyNRWvH33SXnKd7Vl8va7Q9IkSTFOtn0ps26vC3KQ45W5rtv5g0z0s9dN08+28J7qhOZ+6KKAbWkH5ckdQ9wv4Jz7nFJUqbXfZKkusx+zd/NXC6dOClJcvXgolsrFM3xPMBA9Dlfpe5mbQ06kDWPz+Lq6Z9DAXoM1mvTOTb+mleQWb9tbOQjgRckSVOekQofBwCEzgMACgxvSptQLPv6UDxn46q0FMO+UJD9wVu024XiJje5yU03Kd1QBG6Vo2kzZkxqXl6AduaQ2uS7BCJqrPyUJClw4KwkqWVzjwJ8MRkL2tBqfV6gzGwPAoqDJ0BKwxf+RBWfJZj0YD3tdRfi8oip4LcTI3M64Q/K7O3GvLmnAi2Z+QBBquExp6pqQANRUbx7YRyNnP1ysSTJ73KKJCnOdl5ZPiD4Cz7ly+bJaDPIpi8tSpK0wXNSqZ5o5u5zh+h7mAnmpeEK2OA/p1EX2j+yF03dU4xZ7CrGTB5//gVJUsHqfPWNg05OhYMSbi1gHgoGsYj+99ohlUyDTvxqQRfn2ghe9sxhiRQeqNHlp0B7O4JBEl9tv1+S9Jdzz0qSPCpBgaNts0oqbJMkJSlg2TzJD7xDklR1GQR9/pYQDUwxZ4ENWEIxkfShfhx0lGiNqyoaJDlyHqukbpz+bBgABdevO0j7L29Q6j0EzWumkEX/JRD9C0tfkSTNB5zRiiSQZsgqKoT694BKL0yC2r0nvRXmhZk+BjjTtiX6PDyDC2pXF/Ox+IlK/fwVglX5q6qXzRNJ6pkBoQVk0NeGsbUKWMAC6A5FDrKXmOOiia2SpNdtEdrQiMXb9GAbv+nGcl3ZgTVZX2wKd87fqhrrPyRJs72PSJK8enG7pY4jM/OPXNHcDxlHeB6W2GI3PLzLi7l2dp5W06oUSdLTGay/LRdByu2bsPq29yJLZSd6NGlnfmYDl2+tNYbgxlk9iauh0RalxjnmLTMKfHqiDKuiIo0U2Z6gUE003CNJWprELdK0h75XNMHP0NiHJUl+ydW62ntcklRl+7Qk6bY69oK4FngcNFatWk8EYGQ9e9FAE7K3cjvr9IX5q5oZ5LP9HexFp8PgaXQnfX+zhDlc7SMtBoHKs84i77rnvcfvRuBucpOb3HST0g1F4NsPpEiSGp/B7zS10KqoBvzZrw2A+MayQcPNJhBV5DOo1E4CCtmZaMfzI6T4lAaATDeP4uvqX9OufzQBh8d6aWdfFAGHikS0fNLKYgX2oi0zIwikDCaCqs8NtEmSclukFhu+sOg38fM1zP6dJCkxjXcmbP22JGnetV/PhtDOxoOpy+aJpzd+c0ccvOma6pHJeNSXYkDcS6No6vo38IG33+svv+/h1036I1BnjQ/ozHcCNLRQjHVRuVCkpMjnGW8zmr4uFdQSm4qP/cDn59W7l3eNRZj++ICUvIcY28K3HPLeRhDt4ikQ4B0fAYm+OAo/Mz4BIuuo8Ne0N+9oGSCF7+Fl8CRwEesrpQ5LJHkgTrHDIMHDEfDCFQH2mJ/i/z6xk4ruwq86v465zvPgmVkL3tTWwps9ES/qbBvIaLc3spXSgMXW4fe6JGkyIVuzzfgq6+oJsvm5QNvJCZSL7mg9qyYTSF85hFxc3ko7KzoJbr4W0iZJGqyZ1dpR2nNl/J/LoZZFK/Yg215n8KF7xJxXZBhjG38T69SjgMDti8HG393TpuH9oN2NR5jvyvWM/evr+Du4Hv+/3bdB056/L0kKWs/zq9rxgZ9wwcusE9MKK+Hfj13Fulgt5CC3B5nrsNJVNA0fvMZBkHMd/D3mjY/47Bh879g8pdQg+jN9bPklxoMLSbmdGSOofe+aAf1rO+s59cxjkqR0k1zQY3zNfUVOrW2Al60zBJQnjmDRfeo25vjZMZC5T6NLcWZceV4cGkuPhSeOfCwp28U4xe/l+dSmFElSY2ibJKmtljU7s7hHPoFYi097YGnkdCNXhVtInjgyDgKv612vmEk+O5rLnrfnfcbvRuBucpOb3HST0g1F4IsXfyBJKh3GoRPnFayRWFDW/CK+u10jaONXE8xVc40rZFvErzTXC2Lw8QXVbXGQVhiWDqK/palbi/74e++2m0MdfaRZnfDFT50+OKWuk2hC7xI0/tlkfMGZZ0GhHVlZihyjP9Er0IrJ4W2SpPJXOUyzfh6k2pfcp/xGNH6iOVK/HOpNICUrt4s0wqjjBUr8KAj0uVn6uRSDD2/FDOOfL53UG0UgmoqjWCpJgfj3GoLR+GtcoM2ro2OqGgF5ZMZw/Nw2Ck+OdMCTu3eFyHaJd056gugcdpB93A7efTC4XvYGkPaWcPrROkXqXe4JnumdNMi37LgO34kFc4fH8kXsoC+o9t4c4gNN3h5aFYm/saSefk61k3K2xRPk1e49qtFQ+uE1RzwhdxyLaMiOzzHYhVVWts+uiFc/KUl6Mh00lHQA3/XoJZP50+Yly4eDFlFJHPawusxR+vMgaM/10Roxh2FGk0F0wZeRm9Zwk6W0lhhP/DP3KSwP08p+CnnRg8vjS+N54hxzFnLmE+WrL1SRhvtaOhaZZyYWbXgXchUbNa+DJg21JQk03HUJlF7kIrvmcCfocV3xXRpKw1qLboAfc23EHjzWpEiSkpbG9NwwazPNDv6r7qM/t4eCSCuGCxToIhtmphmrbbQDK6DnIbKTcp/B176h91PqMRZAatzw8hgiKaidDJgryfjzh0fitC2Ud7ZH7JYkxXnTv/p9rAmry6X8RBB21xKZOMn9eAAmT2DhxUwzf+m+E/IoZJ3MNbLW+oeIhYSPMaaAhkUFpoPcLwawth6YYS95jVcqPMalxGbSUWOzkGufjjslSWVXmMNPerCvdUwmaTTfZDXVvN/tf5AbgbvJTW5y001KNxSBN2cRxR2eRAvvvfg9HQ0CjRTncJigcMRouWFQ8WJktNpHiRCPduIzCnPdJkmaLObvkMvkNx+++KiCM/FTNd8O2jnij0ZNMNrSXl2nmI0vSpIm5kHpOw7iGz6WAEKL09/KK5K2683x1t2JoIPxO1GpzeYsRkPLYRVs/KIk6cQPiLh/fBk8Wd3PuJt2c+DjdHSStjwND9Zk8M4L69Hc54JATFnB3soZI9vmYBQIZN8gGn9W9LdtEQS9EHNV3mHwe+IC6HAxmqwKbz/8bLc6q/UvgSCIrE2g164XeH7zPOhgLKpIKe1k2XjcweCdf2kKaWXx20V+qpyJu1R73ByHH55dBjeg3fP4k7t3MBZX06iODYOMi3bC/7ODzE/PEhbSWx5L+oMxUOOZs/DkzEqO1JeWYDns68LaGx0aVWQ2FsuOAHh98m0yF4rXgN6GNmXq4kGeWzvEPLiMjAYGpfD3ZIXuG2HQPSOM18oB9ZfHkvkR/Q2KtAVtP6j6VGI1kStPLpsnkhRiI597poh3hSyN6MU4MhvG67AEBp3we1cwqLNhbFBB81hr9kAsiG0HzDmKKsaaPoMVk+1zSt4DWD/2Gd5xOou1l3AChPpUWIHCRlhTESbjoiAeH/GTDuYm+8AVlV3G6onzZk1kb8LS6TqOhTidyfc1XYvaXYf1WbfGtmyenOg2GVVdZC5NbG/V0CGs4+57yATyNj5sl7EcVg0uqaGANeDV9LQkackD3s55E7tQAucBmkrT1TXIO1KKQMiXzYGsxDMg8YmPFSnazM2cB1ZInQ8Ies04SD/6XJY6fNlu06bw/3us4lxL/TuHiFKYy5yT5/RUDevwE9s/GIHf0A289EkAf5Ifm5X/qnu0eoQO/jCYDaiwGReIPRwBupobodqlVyVJO1fA9CCXcTdUELQ6Hc9GvK5nUm/chZlY0HuYd02nSJJur2cR/s0tltSL+Z0dhMAMxPB8/BEY6RitUEgsApYXjOk+X86GkRvAJng+HGaXRKSr/RSC4v/H6ctnymk25U5zICV04xn1/xHm4BonwapDvcaVMs27T/ocUECSCQ52mgNALQTfHBmMyVVNYMk+/zGVt+N2SEhmoW4xY3jdizE9VuWluc1sALNDCOfSCu79/fEFnkls9dasncUXeJ5DIufvJsCZNkBKnm2ADeLpTQe05gr9mV7jNAP9o+tmSXMzc+gzZtJFQy1V5WJmj4iN0e4N/50+zNmjPT46Z1KvMjeZE6Z+3EvtWcX4s+sBBZ271mkonsp3ASbot72Nv58dRalt6QjXrmAO4/RGEbAuauRA1ajdnEgdSZVrO/Mw08FGlfU6G0DRQxzaSbajRMoc84pz0U58u/d18+JaGtvPJriCpaGGg/Fam8JaGrOjFPouMo4xX/ijTrsKW1DOi6GkC7qyUMRNMu6CwBRJUrjXoNqX2PhDQ1BoPS5cQ6O/x+e2kdPynSCk9uwQG+Nno03VvxQ2nV21K1UWwBzYnTw3cw43zlAGQCpvLXI7nHlUi5k8t/vU8msJhQaxXziL2T8my+3qiWNj3TKIwnamocD8LsCTGftFLZhA/EfDcWM8MQNoqElhU21ZxZ6Q2TiivAL61eDPHnL/AErt8Vs54bxu+LRCzgFEZ24HdFwtBUw48lL4TXCn5vzgv+c4LpSxV3DNLObR3qAP63IuMEEpKQSlA8tZf7r/vcfvdqG4yU1uctNNSje2GuE42jwggjSky6PzumpqSWx3YLL8LIbgy9olkFHgwqx2TlJjIaqb5xu9TNJ8D66UmYLjkqTYbd9WXA8B0hwb2tezlHZKV9F+zoynvHoJsLSmgBwdZ9Bj925EewY2LunVDmBOzCRIKiQX7TgRsl2SdHufOUxxaloZG0ABtXUm8Pp+OT/vQWPbQah+g7glwg7F6cASyG9kC3Wc0xbpV6QxhVvm3tLCDCl7Dbmgyzf9Ge/uBRBpfQRIxzkwrVxfUNmoF+4CVzWHlPrzCGpeSb+q2foU3tkPqo5Pww0RVMfhl6bV+drXARoYuHyLJOkPXcbMzAZBZP0+89TxrQX1r2Vu5suXf5F7QCAHmPaYustft5a0ehqE0+zkYFXEIGhf47jPWlvGNV6CRZZp56DJ0Rn4FdVNSmTXA1gy4UdHlD2IW6qjlSXQ4+Rdqyrg33z8Cr3e8F1J0joX8lZlAl1LBkX6Rh6UhqgVY73Eu2f/gsD43ClQ6ali2rujYKNqr2JttRvrabm05zJ99U0wdTwci+ptuleSFLxEIPKO+5GjE8NYLJtjIjVbz7yVHYBnXpxmV64di+StDp4Jr/aWbaWpJ5+EtTUYDF8GLpjDMR0xcnnR9j9k4NbqH8NlYfcx9U2CtyrNWI3RS8j3mfuw7OJfxeXU8TPmKDQ3Sj8dAG1+5AGsieXYsV7hvNNRgRxcvSVSt1Qj53MOAtXd/cxjZD6ui8lom9qMy7HMHKRrjGIsUV3I8EdWIzudlp/66+l7dBgW3mAlCH/rKtZ9mv9mHc5jT3N0wa9w42J90EG/Xq3vlG0Bi2UxlUNzA7djpWYHmqqgVbTfkzOjpnV4Gf5uAZR+6/uM343A3eQmN7npJqUbisATt+JznajBvzyQGK5tTfietAO9W14Bkrw6D6KJXFjQm5yb0IpefI8b8swNGxZ1rbv9jDbteVSJ/iCf43Ecp/Y1aXCBF42feiFbewZAEz8fAellz/2kUNAvAAAgAElEQVSZJMlziCBmaISPcuMJzAW78BeOTIC0WqrRjActtPzGj13RhBMNunJpadk88e8A1aWYQFv+uKcOXyU4GHMe7e0R9Bp9KCLlyd/vB5rswh9b0ws6WB1DQKkyAJSXaL7v6vNShA+Ibc1qePPyIlZK2iyIzNflVJspKJR0H+9ccIGgnrWTirUxoklBZ/EhnkvBD525Busp7zyIZO5faD90TaIuehIMC/zy8uMCnbeDto/0E2BKsN2mBJNh1t5ryglsBFV+zRM5KSrzlv8wc/JNb1MtrxdZcuwCpSWYynXtypOtGGupaoB5Xp9hDmUsUAzNu+yftMkD3rak0F6i9agk6TZT/KkqykdepjBR2+9jhbQcREYTFkj5y8qG9z+q9VG4H++PO278mvuXx5fFRXyx42OMpywqT1k5+Fr7hohZJLYj93c1w/dTWRUqTySIvXoQS65zY5sk6YnLWAsPeRMT6kquUZ9YG7Ym0OUtm+FvXz18D92VrFMvwbtIGwg+JxvffPYQvuzSkue1x4UcvVREoHT1Iu0lBsKD3lD6ZK+KU3oo6/lvj+GP3v8+x8bfi5p2Yu7u6+TA3XTPfkV7YzW3RTwhSYr3MnIay17T/PQqRd9GyYjW+/nuju8SQ/DeRj+rXzDj7ltU1gGs0Sgfc9itE5R9NYSUwZA5uwKOYeVF3s66iczEQj5xlXYGc53KbcVnfrqV1NKUFlOvfiu/nZpn7caONKhqlH2r5JApu/Cl9x6/G4G7yU1uctNNSjcUgR+ORVMndpmULTXr6iJ+n+zX0WqpUWQ4hGSbuuAezcpzosVX1OOXqxwlgt2eTGQ741WQxOnYWe2dRpv7TIASh2tAT1mpxtcZ1qLmYN6/cYQSkmWr8cul95Nx8kqvQ5vfop1LJWjo5PHvS5K2LYES4qf43tmzV83G/5hsEv6XQ3MZHMv1ikMbh81PqCmH/jm9MT2KrpBFcCwYXvk0fETORPyFt7hAerXm4MDOs/RhdDt9Css/ozFP+NVXC7r84zZ4/Fo+/nNXW4ZmFhm7xyhpT+2jIIcNM/h7gwMv6uk1oDuPMHNX5Xn6WRcO+gjfCLryPRmgAytBQWPfNyK2+fp5sv114HavBewI9P2ROvYQD1jXgwycfB1f+H+7n6PGVZen5LsGZNMbwMEbn2EsrMxDIGZ7JMj3UEe3nJ74Q4NmQbUdJzhVk1gMqjq7Z4XCTQlbuzn67u8Dun5yGHSUlpChgCasmKEaUgxTs/Bvp50FAZ+ZBJU+WGHp1EcpMOZc2nv9zLiGbClYSRfmUyRJ2YtDkj9yYJsF3fWcB02P7Yfv/gdTVZBLHMN1lDl2ZjL2+7pAr0OPHpckTQ+HKtGBFRUXR2rtdDOZE76rsfCODA4otZDsqKEB1sDZVvzFXSHgwRW9GSr7DL7v3T+hEvzF88SiasxNVzvNna1X1i0o/yqWa4f9GTPSO6+bJ584D/+/XsicZNlfk8dx2gsNZ01FW/DoWDlyG/FRS2feREZuN0X0TpTgl7absgAxERS2i6hv0cJbIOOD8awpezHj7KpjXzoUlKKiYsp79JxD7rUR3niO0f7KGR9d8SB1NdSXdyffgyXT2Y1cDSTjIy+c26C72vBS+Obu/MDxuxG4m9zkJjfdpHRDEfiOMrSS3Qdk2Vs0oogZENVAHmiuo6xNkrRzEI047tegkgD8fLNWiiRp2JQNDTgPSn87H61558Q5eZqbBnvtT0qSzq4D4QZ5oQlDQxPUCMhQjylCZR0xhfJzQLp7RjPUdA+ZG85G+nO+B615oAA04zClSqOrZxVbgN/r7ZMgm0+/X8j4PWj7NO20nyDX/dnATBX4mssZPEGDszv5zWQnyGJVapvejsPHvLuQvO/5Y0TTG+bpt8cgUf7invUKa8SX27MGn+CiL1F/vwzmIasrXyVF+AfPTGFxxHvyrvg5eDI3eK/WZIMAx+v4Tek2EGXgEvwbDqYPQys9NOULIgxyVl4/MwydzicTwt8P1Jd8rkSOw2RzHAqGxxuCsRTe+l/4veM+46dZB7m7Rd2gxv5p5GNqmoMr1gKIZ0vma+qpxD++OIv1Nf17oKveUyDp8Z4IRaTz/hWeoKC+diyM+JXEJDzO2NS6Ff7v7AHJz3UQK6nZD/rPc+AnPp2doqy5/y5J8h1/a9k8kaTnR0C1t8/hMy3bmaz+bpD+xm7GNpqF9eKcM7GbzTGadFJYLDcTC7jjtMl5XoffPOoJPs/yDVDNLZSnqG3k+XsiGddLoyDpDY5XdcEiVnTPneb2qzfg4SpT/sK3fkDT30E+24OxEBPNrTPBo5hil8LhbWv8nGa6sfKywzOXzRPnBJbZ9m4yq3wGIjUfAsp/e4k1cGARuZyxw6uaNyv0PwqwPmYW/1qSFD0B4i3zxfJ01bBfhPm65OwzPuvVOOcXbFgPhVH48cNrL8irkIODueveudcyhfGtb5MkrR7o10IRllxvC79NyiB7p3MJHhfYWEdDtd2KsiGH57ZwFuJLuuM9x+9G4G5yk5vcdJPSDUXgA4VkRgRP41t0nfRTwBD/Hk/Bn7Q1Aa3U5QQBRNZ560QeGs+aw79UuAASGt2C77u6A9+W3bZB8yFkLqTMo20jezgJ58riVN6gs057zYmq8noTlffBMqh18bdnfJesgyDH6HpQauddZNA8OUc7DznJgX49IEXZHfgLCza0m5Fevy/8qUlOfvU5SEl4MK5TbyWDcH6vwpS5NTfWR3maiwRCVyinH9/f6VaQTta0yUFPgSfxqSDVgApvnVzZJklaSgSZjo3gl11/AuTTuXtaEUnHJUkl394uSYo0N837bjE3kJ+r0uBVEFd8EP2Y7MCX270SX3rwt/Exr1s/ra46fPLnU5ZfIjSmC3/posmNL1rM0us22vYM5YTfsQgQ0y3/DbnxLC3QvyXhQ/yDdKwvr2b8wa5pTuW29SATjrxCDccZH7G5lTziSTJpqjKMH3egUs6rxA4G1n5HktR1lfY8p0GK9k+u03Adz/nPYp0oE7nt7Kbdw6lYln8z76slG3GZzsl7l80TSVrhjSVxwpTHXd/tp2kH2RNvjvAeewv9WCwCSfo0T2nSRR/7jzN/CzbGkduK3FbsZA32D/YoJw6U6FGKXNUNmzsyF1gPzT4rleDiNxNXmJ/slWRNVQQhpzGhNvkHg7CX+niXNcq8efthIYY24jNeW+Gh5jvgizqKl82TJzaC/m2TIPx7Yoc05Em2VtIYyHbUgeUyk8/+kd7o1Aux7BOj/aDq1aWcDVE8cm+zsMhWptv0A5MLH/Ycud49ufQ3KAlrxTvZrtY25LDoPOOay8YyK0rBEj3xw1StfwP+zL0FTxsi+XvNCBa3KwnPwkx8nE7V8/7igogPHP8N3cB1hmCA7xo6eqUxQY/ch5nzQjxugu4mJt5pFsRwsKXdz7GJlB5gAfo2s4EMOljou7sJqpSFXZDLgYBEpyNcjgUCGes6MFtaPSLk6eJ5r0WEPqUY0zttkH512M6qJZmUMectprpYr6klbFwK1cMoo7iN03IeQel4VW1nnA9dP0s2CxO72oZCOJvmr7VNKIkKJ4dNBi+y4d63mY2jujNSkcWkpy1d5FBNbjabc+g8Qb1Dk2xEhQfydF8FJvLRPnh656cZ5/EENraM2gyFHYRvgWG0mzBLO80LBDyv7v4zhVZyAiRsAeGc6qF/BS8xL4PbMF0nRs6oKYgN9gt5tdfPDEO+71QP9EWxlo5Na62Rh4EFXGKF9fSh1QNl5zHUrKgsNrY3X2HTWFuM8Hd3p0iSFtbAR2frpGa76avTLJpaU30xIR+TfKp2RuXFmM5fDsKd13sP/Zm6jKJIvvCyul/g34/v+owkabOD21qibPBmp6nY+NPhYGV7mCp+i4nL5okkXTQKYO84G2655a+t1cxtVAQgpnMt8r7T3HrVqReUH0ewvnYtfRlZZYKOLchw5oypzZGzS81vPC5J6pkhXXbsE4xvRSkB7PipTL0Wy29iTKCtwMGG7m0u1B4NthRdz6a5uoA+1+ayyXeNsOX0JcLLgJZ4eZTxnHPtETPS668ef4e5kHx8FXN11rpL+Z64I5M8AF8jawBxOk/gu3/fjBa6AIG3N6EADqYDupwpbPLBxwE3zwRUKC+YALdvHGs0bC97QOlrrI0Dfv7yMhdmD67ErRhQzrtDCk0d9d1bNPwyc9NpXKzZjexRS9PMYfwYrkmv9GolJ7Ae7eaw1fuR24XiJje5yU03Kd1QBO7vBzKqnyFdyLswXSdPEVD5bBZBqsolNH7zRVDCTKhLT2wBOakOTb8QA+KbXSA9KGMPWs+2EKqYZtDJaACIuTDD3Kv4JqZ85Beb1PY4mnAmEbTVHIjmz6kifWlu7Vn5Okzd6cv8tm0EkzQoBq2bmAKiCOyOUGcG5ttI1Fkz0uzr5slJO+hn2MkYV79Wp5MONHN6DihhJAN0VRUAgstpytEr05jq+V6YWmVnsW78I4nQphbAI/uhTtVsgJfbOrF2Dr0Cr/NXM/0Xy6NV4INbadLCFLzki8vC7+pXJUnRCc9qLJMxD1byjoRkkGRnD2jr8nn+Dsr21sY4XEN1S3y24bo5ItlCQe0TTSCT3J44Ta5hHoK9efeSMWMz6vj8ynisdrv4rOEuzODmw1gY/nkgr4vfob53gCNWIb6g88FOxpttDrN4OqmHfTg4Q/duBKGWTuKCmLlCumS2QP/RQRtVfWebJCnq5L9Lkhw5tHuh0BzaqWH8n/Lo1GVzAKRsH1bdcqpWSlLQJYLRfZtw1Tk8xtQ2ANKOsjHmkXLm8fUx1lVG1me0uHRckuQdZY7gnydIHDsLCu7fbCrpXXldabmrJEljjzB/42dA3reHgQjfimzV1ik+m/gCge7H/44x9hv358d9hjRdAKJ9tsscdnkJOY9cgdXbWcCdm7VJh7WnDRx5oXP7Mjkida4yd5B6YDHvupCt1hgzt2Z3yzvFntLqhXsju+KkYio4IPPafQQHd/S3SZIaZkDO9dG0G9brUoOpPeCXjZUWeQZUvC8MF9tbYV3KqMZleNXw5qF7maPXG0jSKPA9JP8wnrdaSLRYyjDr29wsZpUyHwsds/JZSdsjx9h39D6Zp24E7iY3uclNNyndUAS+voDj7BdqQazbb5tS7WHQwA+ukAaUfAcasKYKNJW+WKDbTW58yiyo4K1tIDPfUwSKKmr5Qc3tafrTWTTecCfa7kwQKKEhFoSy9YcujQTjT21vwm+2dwks9KSzTZL08Nl+HU3CL55dyru6iyg8cyGPdKoHL9BuecElNb2IH/quHnPX4Reunyc55sDAulF4M34gQY6nQdrRtbwjJRYUc94HBDYbdEyhg6RjNQzgq04Jwi/nVYI/sa0Z1J2ffFmFoxzgaEwH/XhfBeE39oBUPJbeVpkXAZ9NnWDlyAysiBcHsJZCJ7J0Rwf+5tcHODTR19kmSQrZiL90m0CozbE5aqplPE0RzPUnr58lGh4AEeZ6YTU1bvuhPu34U0mSo/24JClwgYBXax1oOD23UlPD+GSH+kCRvr4gwuTH4GfmZlL8FvxqdKzR3HI0R0pg4gwBvZ5KrLAdCZOKbCTI1NSOhdHhh7Wz29xfeqGyXIt5oM/MvwSV1T1FLOKjXsRt2oOQQ4+FQh3vBMkX1xDjUMkymCJpcQ2BxPJa+p6fWqeTW/D7p5s7PaNM+mBzDvVHx5vq1bEKuRmvbpMkpZlytBHBJrY0cFyStO1hl2J6TBmDRoJ7f7CJVNvWn8Bb/32BSnkNq+fNJ2jPZoMvu54HtdZ/0qlAc6NPmCfrO6gE68OZhgN4sh3f85JHknqn6HvAyCUz0k9dN0/MGR3tjaWNusRJFa+ABycvsxdU9yDT4SYlr6d3h4bvZ97sl0DKLXGgYe9K0LpfOtZaXEemOpdM7CLEyNoc+8VQOe+0FUcqJBNEnzxJMPT4BdIU7U0w+0xEhladBWnPh7O32caxkptm8QTM5Zi65dNH1DpEe9tSVn/g+N0I3E1ucpObblK6oQi8zPi6doWCyp477JBlMiNC43DyTB8zR8Sz+NyxakHVZaC5U/Fo0ogmkHhIJlre605QU+Jfd+r7XviC15piVAkdIKKJJINwF+IV6QeCyLOBYkcHyXxJDAEt9CxuUGyL8XsV0a+dHaDYI2P4qc77gd5Xxq9Q1JZnJUmnF0i9+vQyeDJkB4n8ZA1IPO/tViVsQhP7t3No6PAkYwgeZPyZ7eP69xBu5Lm7gH4VfhMk1j4J/1L34bPsGU1QuQvEbVlo/pJ00MfE95mPzttiFeEH2mwo5reucvz595ga+2MRQ3qtjfQnh8lsGswG0U+VY92Mb+D/0T1dqkz8Mv2YewdVXT+lXEE+KrJ5eVe3n+pTmY/ORniRHsBv/FaDnNNdhaqqxbfv18jRZJ+9PGP/DEinyEImLnV46q/X8NwVC/94zVGylCq2HJckraxbkKw/lyT5roFPGbMg+tZqZCAmJFm+5g7RFc/gs7QXIlsuD2RqvoUlVl9Yq9WFxCDCO98psXvLsviy6nVQ2fgjWDoLXzugpAc5MBQ5i+xe3QpyLjiF1TYY6VDEz/BHZ36c7+oPYe0mbWTsUQ0mve2ZSc3FYWXl++EvvnTe3GU5AKrdv7BGNStB3AVmbEG5oMTX2rCENytKTZH8Jjqc9dM0S3921nN4aOkeYg5HqiLlqMASGMhZ/u1NKebgTbfJlnI66tR8CRku68WKPpAEmnawXWi0r17BTW2SpGAvYj2PRdCHr2XT3oshIOiO/Flpkd+E1SE/9WkU6ur3BbWXLE3rtRbmZPOjZPr4/dCUw1iB1efXPKTZW5iHaJOC7DVMJlSQB3udPR2rN+NKgKY8kcfKgXd48sB7jt+NwN3kJje56SalG4rAo2wg1DMH0ML+J2M1vR3kUFwKSnrDZEpsMjecD9lnNecisr592txJ6I/mOlmOX87jH9skSQtfidPWUyDHykRzg3suqMDRSnQ4srtSnTmgJC8vNHVPAM7I5OTjkqS2Q7kavpvj0/tMwf9TK0yO69P4mhOi8EO6XklRsI3Ml6jk5d+qvXgFHVqcj9/2yJXzWhFB30cXQEhjAvkVVIAkOtcM684A0NRwPRkbR8z9lIlz+KPnrjCmrgSbfLy/IUlqOcMBkl2mkNDrD3MI5CErXCebQJL2UXzC3Rmg9KmzoO7apQXtCYRv/a0cYx9KIte52oe52/QdUO3cA1maniVmEPZL3Eo/lmHulyw3Oc0FB1TRbpyd1WSNXN4H+vlaK6jl8U2pWpogEyRvED/rgAOelnWBmG0uzg0sBNh0rgL+PBAFYhpdwbx6d5rskZFYudJBQYOltBMcxXdXZpDN4PwlxQ4jF40C9Xe+SfZT4G1YQOv8QHRvBs1p+0UsoBPLysn5v+SRRvyluRFfePD2Wi16IMOv2rHa0vvx88ZfMWWBP75V/i1YeWdPYClu3YM8NflwriBv0qDurG1qfoK247aTFeW1jxhQTgfxpscDG7RhBsR49R7kNH0UX/Bes+ZKu9pljjUoPojYgGVKF7fGpJl+tkmSknJaVDDHWgpOHFs2Txwx8DdmBovBP25efaP0OTQBeRwIxfc8ewkrd21am2p88DuP+tHn+83BoypjMHoXsR66p2YV38vzlwZZY8kZ7CmpB5Dt7kMDKlrFWYG6x8xhHA/2gvMJeAu+eHuQOnrZmw68kiJJavg470h8g30sdpR4w7SVJlsr8xm0+YPvCb2hG/h5LxbE/EucYIrzr5BHA8L0gif1IWZ2sSAu97JJLLk8ZPOEOVV+bBh9Z3FSBPVR3avfnBaMKiuTI56TT77m5JhXBfZ+0Aomb2GmU7OLbGD5PgjiymHMu5lITFp7Xrm6FlnQ329C4HaYOttLt2L6jV9i027NitLZHlNhLSB82TzZZmezKh/FRL09365XhtgEMsxFuRGmCl57uKnTEbVWV5q/J0naNUx/FvsxIY8cxbWw6lEW8pRnpjIOcjuO526Eoe9NTPGZo4zx6eE5paQwntMbGe9iPel6wVtZyGveqtfbcXzmHIYXikDIYlJYnG+2kkp1d02VVmcTQJqfvv6UyncowlyePJBHMLM6blKLfbwr9/MsIs/+f5EkvRFu3CYXx+QqYJO5sEBaaJgnpm9aLONezGCxD50PVHAiK/VrLQQo81bTzlwSIMNrdovqluBhsrk4ONa4/sLTUiRJxdFtGjM15NvNSUD/e+ifhwsXl93U2NgzOqn5MOR+NvmDD2e8H9W8QoAs/OsEGtufGlDwGICnZAHlFLIGxeGzA7n3vdom710AgeBTBvj0wst7WxjfpTQ2swivt9XyMP33dnIgaWMVSuPS3WzSdzYFaL6HzXLNcbaP2kUUZFAOboT1lWNq2YWsVLab+ykzCWOPHUFW+sxBrLHCNHXmsIk6yweXzZOYed6tWLNhLqVq5QTt7BswQcZZ5GLIxgbauDFVSS+bipej8Cm41dzslG/qDjXgAtpWVq0QJ66YKZafXjQHmPZ1onDetju0xdyLu2Uf3520kbL5V77IsFq7FBvNHvT0bexNw13I44I/Y+huRIZu3xqionGAyki1UfZ3vff43S4UN7nJTW66SemGIvDNXaDEUzEERjy9EnVHOGZp2xKpTrEuAiyVwRyZHozy1fw4SDl9BOTstR9kaqvDlI1YhZZ748lRJbRihoyk4mIIzkK7T3aCNoJtaUrvA+3PTpDE/9xqzJ7Nvrgj0k/fq5YkzN2UEI7CnhvCnB8eAFmszAbVlPtXKnqIwFpr6uiyeZJTQhmAn7zRJkk6MWhXXhDjOdsJStwRAJIcSwO1JJZd1mA7t4Rc2mJuYn/DoKAMeHLxab6/c+cFBTkxUY9PYlr+KJ6xPNxHu7HtS5o2ldVmT9GPkiWQ92FTAzk6aUpp7aCCmDUgwLJA6kkknaG9LXtx0Sz0zcvH31gsv4RVkhLNPCeN0e9Xow4pcx5Lo+MciOnOHdSOGT4P6r+Q4KdEL0xmWwHy0fcGSDPCB1R6yk6fxi1fTQVhzW3ZSOB1qAIrLzGMwKeHl7d8njS3sgQgr+fXmmPrKdTFmc4OUGA5SOuKuXjoc6/glnrrTnj142gw0gaPPPV2U8KhOXD5VfckKSAEtO16Bplc3OGn0HnGEdvKZ5ENzE1DIe+w1XWr2lTne3gtSPutGYP4zNF3j0R4cLR5r0KisZLXbvixJOnMueOSpOA23lPVsUErirFwyhrh/R5jvXVfwIpxFvgofp41MbXBpOyWs9XMFYLwO3qwJqKqu+Udx298TLB9OTT3zm30TyMXj0at15VY1rfNgPOlCeQ80kV+7+xPjujoLMj2zkfM/lPFutnuxJKps7CSnJlJmolm7xhowA2bkYvsXXL+vSRp3dVbNRGOJ6Enj0ip3xVT6/sSshMY3qNZG+PLcGDBRPbDg3w77spTaczHW1XDCgplPiOGUj5w/G4E7iY3uclNNyndUAReugSKum8BJFSZ2CfNo6kurcU/FNf4x5KksEmiIF2BDUo0d/lNLKC5er3QVEUGDddfJaiwtahYDdOgV78h0vwabfi2glIo6DOy9KTW9XBEujcKf++mZ0FLodtNemNcqUpMwMJvY4okKaIL391FP7TlpJM79Uqa75RrP/AruP5fzUgfvW6enDWHde6+H/Ry9uvtmluJ9ZHaiH91Npf+jU4QWL063KbwKNBcUBfIwTuQsfhPgAC98vDxvVaXroW95gj+ad6x3dw72vgFfITDP3eo6xHQ6poGfHhWBUjCbupBB7VGKDEGZPyT0yDRv4wHfX57EaR64CyQZzxzWFYM6Hkx+rgZ6b7r5snzG0w7l/H9F7TYNH0AROLfbtKrxFiy94EeM0/mqdFcBb7JA0ugOQ5fuo85Qh5aC0o7MH9GR9qQkzej4FPxPnyYIW3IWNTmNnnEIDuzpi67c4oxbfQlba7u9Uol5eEY3TXEc68G0a+FKeRk7x7QetPhKbUlpkiSVoVdMCNdxuWPkrp2mFta7AT+R1oqlNcPKqy/Az/tkDlM40wxtbkfSNYmJwfMSv0Zz9K/M3+9nwPRz4+ashMLQ7LfSuyi51kQaEwncuabivW3Lv+iLp5jviOKiDdVN5hqoTHI8txwn8bjsbZLS7F+7vaE984JZK4olD2goz5WDdPmiLl/1LL4IUnNTchIdCxrpmHximQDXXflwXvHChD5/QdTJEk/6PHSlnyQduM59paRLILaR4cohLXyKHuMd3iOPGexRnrSt0uSJnu+Z8ZCWuBI8Bo5Y7AiokrZi3YFEFtpiCRhY8o+KY+rvN/PG4vASsKKf+MgfIsKBsUHJ1Up62WzR5kia+9HbgTuJje5yU03Kd1QBO4bSSrY435kP+y3ZaveG21+dQktPj9BhoSP0NC5TTEKfwDEceY0Ee2R1jZJksObQyyBkyTdz3pJCR74q2pu5bhrzBVKSW5bAjE3TkVpMs8UpprA/zX7CAitpQ3UsnHGplfr8P1mLoJWNgiElbcWZDLRCuIZjyiX9wXQeaa/Y9k8aTA3qIwPgySvZm2Wdxu+sbwokOjEReIDgzO0P50n5TWjrUeLQE+nmoiw7woyBafS8A2Wl17SOl/abh0EDQ0Y/57jKIhu7z3d6niKkpnfEHNz6wHGX9hGRL9F0/qOE19ntkmxeqMev3GHGffz4UTX1zg3K6EN3q6w5SybJwM/xVf74HrEc7I7Tn2LjGe6GqurvITiSFnVIOmLS1cU8Bz+xr4DWA02U5+6wdwu88A4yOxwfK/yt+5mfK3IZHclfuLhFSDnVR0+KvfnXSHmNvmCSpCSUmkvdP+oohuwfNpX0tfVB7EQlpxkM1S3Mz/j/oFaHU46n4b6l80TSZpcYv58jf8+ri5d9hTGX/kY81YYRAyoydR83xPoqVeDQZNLZ5DlkbtYT2tz4LOrmnXlORGqpR9jxcR5En8ZiMWaCXeRwtp1wULrrsEAACAASURBVEuLGYxjXTqWycC8KXlgY/3Mn/eVRyB9/fICmWKOxJclSYk+rPOftWDFePeH6uIU/VmRfmLZPNmZBqK/1Eqfolb2q9oXOQhqAvXnPMkcHIkCr973oJ+6D7MG7LFYTEGHSCOsycfSaN4Mb9ZbFzUTgncgvoZ3hM+zHo/1YtFMjpQq7l72nfoq7nENy4J/0wBxDdSHKjCLNWofRDaSQ+nP5Fb4GOzP+pkbjtB4AWuz5kTLB47fjcDd5CY3uekmpRuKwL3HOLq+Rmja0J5J9fqhtQv7QUJ5PnTJMuU9a1y7NPIqh0JCF4j+xpSg1sZKyTqIXTRlZreWaPI50Mk9JfiOAs0tLeXhaMuI3lw1m5s6VseC9vuy8QUW2UD97b536/fb+a6hlnc5cmnXWYlWT+0g06Eqslj+zSCyiyU8/9Fl8CS0n34lmxIAOUPdulAACmp3kldb0o3PutMPRNjT0SrbrEEOfWTLrNiWIkl68Rz+uvjD+OFzS7aooRZ0GT8ET6aisCbC4kBDbfUjGlz/XUlSYRfWSHcpxeW9+/Cpdwas0afrQf1nTDnUiSCQxMe96e9kBJkvq6oj1VuE3768G19j0TJ4MpPIwYmJaI5h9555WU2LWDw5B/A5n6/CJ/7UPHzLm5xXZD5+zFMzyEPAACjQy5/xNgTAT2fjoC6P4OsNWwV6nLXBo7DLoPbOvPM6MI+P0jEEGqsrRkYXCkF9cW/bNZUBv+LfxMqpCAVNzvUYX/QwaNAVO6Sh4/ApNih5Gdz4v+Qby1o5EkSb+wPjNL4EH+5dwpKr8yGO492GjFdGNcrZh6/WowpL0T8aebryY7JJwjPhRfjsiPwXza1ZNuSozJczBJONyErwtE2RgazN7u+x/uR8UZKUl0xW11jmCY0HYSH1+pnxm+JrDj94GOmDNVB76090fwf8GJr1WTZPzr2NJZU0zbyVjdytuHXflCRdsoPyo+ZA2z4mM+ebZ2d0RzDWVNMUPv7YPfBrvydW5tUzyO/XvBO0u9XcGJRLHv/ZOg7nBBvrZ+u9G/R6IPtW5CDvGhpjrgI3g5FTl5LV3EymV7w/v1mI4NzJ6AzzExpLYa2eswGKbKcfxRsjP3D8N3QDD69kMfduhDm2K5ZsxGC0YiO1JJw/YsO0G1PZvu+YvOYxa1wuzJzhJxCKsIfZQI4J4d10rFX+ZkH5nWNjdBSwmKfbzUnFqTIlRGAC+VxmQXXVshknjZuKaVn9eikZYU+aY3OftRFAzApkYR7dhvBbV64o/izPdThx6eiPr58nGdEshrrL8Ga6qkyJkbgoKicwXy8tfU2SlD9qzKqVr+ro/J9IkhIa4UHcaRby1t30MziA4M54aaCuOjDnthWwwXanokCnHKR61SQXyK8QHoRG8O7YLtw41SOmAuLGAP2shQ0xrJL56LyVzbP2FX6TvUCwyG9TlFoC+c2mfc7rZ4ahhTgWd/k5NogFj0jd0kVwaaQPd9nvbWPhtT8LT2yp/qpfcVySFDnCZmH10d8Ac5aosfpHtBGfqE92M75jDubu1jMsrrpbWBKbL9v0aiiL0CMPhZJpakiPPEZdiqnoJVlLfBeWAA9m7GxClotFvtKcujwZ/6LCVlMh0FW+ftk8kaT8Tua0aJL1MzcdqbQh5quxi35Hf5nNsP8NczinulmtKWxWxdlsHP0+rLWpWZ7dUoXb5ck716vkPP3u9WWM6/xQ1nYXfDqR3aS0eTbn+WQCd8H9uJh6PU0d9+ZErdqBUqg8Za4j82pjEMZNGRbP/BWOFsi5E1dhzd8v/9DXVBuuop9/Clnc3PSEZv6eVMpbM9gnYvrpQ0MI7oh9U/ma2sz+Elm2nTHYzfWCb3J9XqSFXP0/ober+iL1ZjwMsMqqx1112JwG3hXwuh45z+9rt+AmmTOVBu3evDt5qENvRPHvzCKUpNcsKdMT0wCFmcvMgz02QNPJ8CKp94PXj9uF4iY3uclNNyndUAQeuA003ODA9AjZMqyucyCGDaFoeu9ZunToAZDuyvQ0LV0GQeZvxNSotXPTiscwmvZjPZiv572i5BVG0GRgnGDCjDlKn24DzY0Pe0sxPDfiSari/gje1VWQIkkKWnpFJWMgp+YKzGVXCOhneB39THuWwytxD/nIsZfnF2euLpsnFzxARZ7F6NLhic1qqwQNz+SbI+FduA0qbgExjzf569OXqdN9OAoEMrcaJ8XcIdD1kAlUBdrOa2AL6PK5eQItnz1N+6+sNiUIunq18AIuhPK7cb34mbIHAZsZk8/oLu3cCFJqeNuYnU/yzsWtzGt+MChkYmlcBV6841wrJu5n11w/T5LNbUChx3AT2VbUy3UcczPndvg18BwNJkXyzs7kg9rSgjtk5izV/hpTmOfgYGPqj3JoqnN6WHUPgxAj30YGfhaYwrs8eGesp6WSJBDzcCzPT8wTDLxow9qZdqToD6OwCsuOguhDzAW/w6NYbqGFoK47LsTrtVh4kuOoNCPdcf1MkRS0kzE//zgW563ZUqsdeYzLxwJ49S2Q6LZFatr0FCUoKgo0WBP3N5KkmAHS6wLsjOPKCizH1ZcDdWQak313Mr+Z6sKVlj2K7Ny77vOaH0DGnKH0/+gk6ZDldspf5Pgmq3uc9/uO4MJsNLdKTfbCr7h+5M2eFqWKf4FX9yw1LosfkhRXTEJC9gn6XZN9VXEbGO+VaKy2gGL2mHEPXCifGg3UmRrmv90cOHt9rE2SFF3Iuo+NZN4qvtel4LtxPYZ0M/99aznX/nsWqZKX+nz1OePerL/Iu+N38LfnvzAvtlVO3bLInnHOJAMk+CMrW9/GWh0KxzIbcMwpcC1WzuT5cx84fjcCd5Ob3OSmm5RuKAJvHf+pJCkumWvb099skW0af96F1/AFr9gGAko3/qKJjlLFrEVbPh+A72nbFmpNd/wA7VT6IAHG+LEA7e8H8f3ECyS+KgmU2duCj9kn+VFltpFcHxKBRuywgWI9zG0vPotpOjtsglMJBF1ODqBZP5aAb/1SPshvZU+t3nKBHPK0dtk8cYWDaiue4n23xIwo5SHG/oOj+HDDzcXu+3pALy/fH6HhFtDPrjR8ihVeICS/ZLR4fR3+ukBfL22YI/jo30pD/5SJ73JLK0fhqwsfVI6pa71ljkMKHgMgr2YX/cuNi5d97klJUkCSuVHG19zlFwGSa2oEIcbu61doAgGklRXLLy+QfZx5afocqGqxz6GpQg6/FF/En1u/F9/giklQ7c+7ffS3nsayyKYfvSdAV9vHiAvErgIxzTdHqPEJnvddTZAudw6LwyemjWdnCjTRwbxeDgal73BhzfXVY92ss9Wq6ikCW2klWEtXfOF/az+8WdWMddI+s0HBJ5DtkG2nzEj/aFl8OV+ONXSftwkQxkVqfAY0f8mBnHuEw6fuaKzSztlsbW1ENlKC+K4uEUtl52lQ8aUO0uOyO30Vdh9yFXKetMEgc3jrsBP5KGqp1DlPgm2Tizy/6RbGntwA/5sd8+p0InPZNio5uoKRq4kE+NU+Qns2X0/F3m1uBjrBZ59ZBk9mRx6TJPVPg67nGuyKcCLnwetAuGXt+JNz40hl/JqX9PGj9GvgYfhXMPw5SdLqy8hrogv/duUXX1Lyj5HlY/cjDx3nzH2sw8hQkXekTgbDp6BaLIJSE7DO3UcKY8OgXVY61sj6IRNX6GVfG41kXqMCmYe+BH95HYaXLe9U0HofciNwN7nJTW66SemGIvC2kf8tSbojkKhuT0mgSgdBCvYpUJfTy/iE50C6aZpXVycIe0XYO4ViQAcxm0HODSOmRndDl04Hg0hdG1IkSV5PtkmSgkx2QUfbRTUM8/ulXrRvYziobtUixW4WPnpRcZd4LqAZ7R1/APRb/RTtPnAv2vJ/Ns9rfRwpSN3py68H7luJVt8zS5+aEjsV/iJR6t3RZDT87DMgt0lTN/nW0gpVfgntf85CBy+9hT/6pRF89nmZ+NWmJ7zV+RZjSdr5/7H33fFtHmeaz4AECRAkwd7AAvbeqS5aVLFlS+41iaNsnGTTs6mbbMnuZu+2/5L13iWbyyVOd+zETbbVrN5FiWKn2BvYOwECIAmCIHF/POMc1+doRW8iHZJ5fj/9KBIfvm/mnXfeed4y81GOm47I0qQHeb/gq/HQybI/u5aVL6sefj+zlIwk/NwZjBs+zX4GsmSrLJiMTgQ8yfuHkuHYbNmw6jlW+bvWLRIc/gD77W0+x76M7UXgLFlKhox5jh0mQ7m2hRtvnhnUom6GrPeh7WTeB/+SxynY2lnqFLjM7yb5ByKpgvHM+UHGt9sdjMlmTzHPYNU8h8kQHlaUV8NxrS6nbm3fywoPU3UWIu/lRqfhNjLAUkF5zRWSXV07TCanCzLgVDyZ8JQ853w9b24CALueenA+gbIoNpVj5iTZeME+Vo/EPU89bwvimehbyqeRNch2f8fBdm+6m/HZRgPn2MIwxzoosARJgzym9zkt8xC7xiQDTKK82s7Uw9/Mct4UDfMwtjm2YbWZHqP2vjjMWjiPjUay9ZlW5q8G3WSf0W7q7Y632mGrYAzeVrZ+b23FTm/CP5iVSw9YTJjO4jNqDtJrvncLWfpUJ/ui7StFTRbnXf35KrZzlqWQNbK0eGATGXnS0SCcKaMuawIpg9KNzMlZ57lJzTPojwkdrwmOMPN7k/L4i1R6YNkeDVpN9Ag8GfTkaps4Dolx/O5VGythcgxjiE7nGJ91Jd20/4qBKygoKPgobisDn4/5BgBgIIKVDovO40iK/yoAwKjhijh7gzHXJBsPgB/e2Ayblc3MHWM8unVaxtU2kv0U9JGZzOb5w8WCC4ReIru45CTDf+x/My7ac18Y8rdLJvNTbh/fa2b9coyLbXijdgc26bmRob2S7dlQy+8MywOIvnOWbPRp/VZ0z5E9Zw/yJw7cukxmShlP3hjLrH/tGzugNzEem6QhU3vKQJbhucGVf6IoFGmh/CzuW6zprTfJd/HtlodbGdhvw+QobBGUk38CY3lZe8kyWuTLIDyrRxCmY2a9o5fx7JRHZK3qJTL7yE2lsI6RrYZ5Kf8tRazMOT7KtwANr/LN8bsCmtC+jSzDWU0muJ43sIfUk/GmL5MxOQKXoQ8n6z/lJEtZtPHQoIQhskpdQDisEYxN1wgym/JpXtsxROYUVC+re0INWN3AoxWEhqzo4xWMT/6qhd7YSNBXEOfPlxrM1ZAFmViCjvRXyfANOfO4ALKnZHmQU3s5xy70DGOg+gW2aS7pLXywh6z81cWhWxfGGkToqdPF4azamG1fgLFAbnqaph6NZTM+W7mFOYz5C6/iejL7eMBBD8RlpffYvJcx57heyvYXpuuocrOvOWP0KDos8u0/pWSzbRXZ+MsJHrn7wgx178w1uUkugl5huecw/D0cl5Zp6l5cENtcFcdrrnnY3p8mNyJ1kLKyFa1/g1NsGu8/LuPcn82/ju+C8zqqiLHwxjb2KSqDehBstCFxH/ve9hN6CnkllONcI6tGZk8x3xOsy4f2cXoGAS/LTYZaxrW18/zOUVsUHipjv6b7+dnmSuZblkKYE7mk6UHqYeYKho20RfdtpQ4eC2a7xi6xD+bmSQybqI+a1cmb9l8xcAUFBQUfxW1l4EVtHwcA9NjIEgq15bi6kez38xrW6L5Uws9cF1hrmlE6iIEOxkS7Q8g6jTrGKRtCWGu6OsPY287mXswmyPdJ7mEcTGi4IlaHcSWzjbdiaYLdjktlNUpnEZne4BhjpYahWtjlQUpLWmbarxUxlhnRzt18z1j5tuk39TbkXiZL7a1YWrdMHtEw9nqonbsHo7e8jNEwMpJxWRmR104GXhNDJpXRNQpXALfvO/PJmDcnkbWa5SFXrTNk4v6eOogcxkCXx8m02q3cor4ZZBZi22fh0FHeexPktnMbmaUnlwxyIeIolnI4RvH1/J7Nj+yiYAvHxzHGvowZBQzLZBCJ05dkT3fcskw+3E0W1HWFY3jXI/WYSCGbHhHsZ0Ea23VW0JuItRuxUmwBAFT0ctv9RAe9prgT9Ixu7KYcwnEDMy30PraYyaJeWeT9y2LIOJMDQvGdIOYDnr2Lns+5Pta/1wXx/kW1h5Cew+qDIAvZ0xt1zMtsuZ/yrF+krMv1ZrQdYKy59Oh7O8xKtNAr6g8gawwxRqNavujiYflShm4/suILRyn3hZ1bUGJlu0/Ld8k+UCkrJFxk4lOrjGHv7w/Aja3yvbOzvEZrolxcGup20eQK/t7N3EmlfM9lPh079H6PsexXqqrw5y1kvxeyWV01F8Y5G/MmY+KfrKQ3N+Q+ja581uunX49Yt0xm5+SxyqDH94/JfmgC3fByuYW+aSf7EjjI+WRKeT9e1r0CAHh4js+80s6qMr2Rc8Q9ynkUl92A0SbakPBZ2h+/bo5xzEO89hO2cLSt0rtLqGLsu9lCDyS2j3LTpU+gN4/jX9hIPXz9+2xzTBbnyj5Zr++M3IKJ49TDXfufu2n/b6sBzy9miEJXRJdreioNT3dS2K+F0A2vHGQSzhRNA1L7ajucD9Hl2H6Jk3f1dW5XhYcTMyObAn09JQ6BUSz5in+BRiajmMmTq70MUUSX3oOmJv7fVMWBXWrgohHY+TMAwMrTudA00pAtWKho6VlMWCQGs6jfpuVC4T/sQM3DdOctmpsnHN4Nb3yfSmWr4v32GyPQlkCDuOUcNxUc2UMjhXa6ZWNbAGczP1uqoCw8XfKtRSa6Y2GrTJ5Y+x9GeR+NVFO+fINKOjOLZ6RM9kSfx/wwFW5igS5pkosLVmoUF8cGaz4+uJ9j0vJzCwCgtIgL16F5qlFCGPt/2mxB5Rt07s7l0PhtWYcBbzNzkVyU71Ec8rsA5wC3G7f1U07N4OTJSuICG1l8ClGnOAFq4rmppiCAxqc9nOWmd3np5g6mBmOykwbuRB4NYHkzx3VgG++XGDKDyhEm6QbDJHGwsv+7B3l6nzvJhYtWliGWyTfZfPka5ec6SrnNB9CQXR63wJRdBQDIC4m7ZVmshTudbWxy8J7eqy6UJFG/XTJZaGjiNVGPM4HbNp6N3lnOhaIA9uPGIVrc2VwmoTMnaay6OnvQ2cPFKdHDBWHGxH6Yatj3vMZVrJRLkhDMuVF2jknNjmLK/VFbAl5eMQMAVuRZR/ntbPNqJWNpM1qGKCwvZGHWwGuadzLM8sl1yCQinovJL6O4mJit92PfDZK1o0W0JRkDMjxyimfSB2UM4sGztEHIop4+slEeFXCIC05cBudPQIgRUVP820QW7YV7mXMtvJuG/XrgGaRpObdqb7A9xbnyLJRAhrJsrziw8mleH9BJPTQ+wnDsfP/z/NlIvYoqqsXKXpKYbuvN3y2gQigKCgoKPorbysD/qocr4iPRdFsWz55D9VYyoKgOMseXA8imty7IN0qLQOBZuiUvf52M++4glvTNNtFFOpZIllBqncKAnUwhdgdXux/Jw3PM25nA8Tt0BpEeul3VJxmaKN5At7FFsLwuabgdooVsYLqcK2HuOO/Tn8ANQUt18o09CzFoiSK7LJ98O1xw64h6kGvoHpnX8owtIN3OZ37d+/cAgM/+O1leyJ+THQYPJKN8OxMi3VYysKhAumd9GRa2q4dsa0KXid3xZCdtc5Tt+ArZ0O4HyGbnvhsDzw6yij2LHIfqFbrVw1ayD0OowJVf8Gz1zTuYzbsm3+2XUS6Ty6tkEA92LGBewzGe7zeuWyZjrR8GAARl0rOp6UnC/ru5+eVSKNmrV0+PIfICPQW9Kxl9wQxDdQywFK7EQV2YvZeewlw92ak9UoPCcCaxZhrYX8s0dcxUR1k1nV7GfDbd6poEjn2BjtdekG9fiY2MwfuTWb735kWGLkQhWVqtPDu6NJq6tZSfAd0PqL+h/iPrlgkAiDEy6XIPjxXofrQGQwscyxgLdTAngx7P7EwVAGCLexhG+Vb2UzqGK7fJ0OH4a2Tbp3fTm8nf9QD8LrPdW1rlWegWMsvrBXx2tXEChgHOTf975CmC2pcAALs6GOJZPGuFxcR7lnTJZF4G56PrBufcyFU+u/tpFwLbeW2pzbBumcylM5S2c5ZjPd7aho5AJtdXYjiP7IucqwOFDDvu71zCsXuo1wf+J3W6y8JrC7bQa1uSb7lvqC1AbwplmjTJMbYZuUlwViaKdecXcFLqe0AEveUaC21JXgjHejhuAp+uo+fympbeWloX+x34CL37K1doc4xXV/DEg5T7zNnxm/ZfMXAFBQUFH4Xwvoc3QSsoKCgo3HkoBq6goKDgo1AGXEFBQcFHoQy4goKCgo9CGXAFBQUFH4Uy4AoKCgo+CmXAFRQUFHwUyoArKCgo+CiUAVdQUFDwUSgDrqCgoOCjUAZcQUFBwUehDLiCgoKCj0IZcAUFBQUfhTLgCgoKCj4KZcAVFBQUfBTKgCsoKCj4KJQBV1BQUPBRKAOuoKCg4KNQBlxBQUHBR6EMuIKCgoKPQhlwBQUFBR+FMuAKCgoKPgplwBUUFBR8FMqAKygoKPgolAFXUFBQ8FEoA66goKDgo1AGXEFBQcFHoQy4goKCgo9CGXAFBQUFH4Uy4AoKCgo+CmXAFRQUFHwUyoArKCgo+CiUAVdQUFDwUSgDrqCgoOCjUAZcQUFBwUehDLiCgoKCj0IZcAUFBQUfhTLgCgoKCj4KZcAVFBQUfBTKgCsoKCj4KJQBV1BQUPBRKAOuoKCg4KNQBlxBQUHBR6EMuIKCgoKPQhlwBQUFBR+FMuAKCgoKPorfGwMuhPiJEOLv7nQ77hSEENlCiAYhhEMI8Sd3uj13AkIIixBiz51uhy9CCPENIcTzN/m8VQhRdRub5NMQQniFEBm/6+f4/64foHDb8FUA57xeb+mdbojC7x+8Xm/+nW7DbxtCCAuAj3m93lN3ui3vFb83DFwBKQBa3+0DIYTfbW6Lz0IIoUiNgs/ogc8acCFEqRCiXoYMfgVAt+azPxZC9AghZoUQbwohEtZ8do8QolMIMSeE+K4Q4rwQ4mN3pBO/JQghzgDYCeA7QginEOIFIcT/EkIcFULMA9gphDAKIX4mhJgSQgwIIb4uhNDI7/sJIb4lhJgWQvQLIT4rXUCfUOJ3oEQI0SzH91dCCB3wn+qEVwjxGSFEN4BuQTwrhJiU92kWQhTIawOFEN8UQgwKISaEEN8TQujvUF/fE4QQXxNCjMi50ymE2C0/CpA64pAhk4o13/l1eEqGW16R8nXIeVh8RzrzHiGE+DmAZACH5Jz5qtSDjwohBgGcEUJUCSGG3/G9tXLwE0L8hRCiV8qhTgiR9C7P2i6EGBJC7Pytd8Tr9frcPwABAAYAfBGAFsDjAJYB/B2AXQCmAZQBCATwbQAX5PeiANgBPAqGjz4vv/exO92n34JMzr3dDwA/ATAHYBu4SOsA/AzAGwBCAJgBdAH4qLz+kwDaACQCCAdwCoAXgP+d7tc6ZWABUAMgAUAEgHbZt9+oE/J7XgAn5Xf0APYCqAMQBkAAyAUQL6/9NwBvymtDABwC8I93uu/rkFE2gCEACfJ3M4B0AN8A4AKwD4AfgH8EcPUdst0j//8NOW8el/PvKwD6AWjvdP/eg7683Sez1IOfATBIPagCMHyT7/wpgBYpUwGgGEDkGp3KkLo0BGDj76QPd1qI71HwdwEYBSDW/O0KaMB/COBf1vw9WCqbGcCHAFSv+UxI4f4+GvCfrfnMD8ASgLw1f/sEGDMHgDMAPrHmsz3wXQP+wTW//wuA791MJ+TvXgC71ny+C1zgNgPQvENf5gGkr/nbFgD9d7rv65BRBoBJOcbaNX//BoBTa37PA7D4DtmuNeBrjbsGwBiAyjvdv/egL+804GlrPv/PDHgngId+w729AP4cJJqFv6s++GoIJQHAiFdKSmJgzWdv/x9er9cJYAaASX42tOYzL4D/4CL9HmFozf+j8H+9lrcxAMoEeIdc3vF/X8P4mv8vgMb6ZjrxNtbqxRkA3wHw7wAmhBDfF0KEAogGEASgTghhE0LYALwl/+4T8Hq9PQC+ABrhSSHEL9eEk94pO91Nwmhr5bUKzqOE33CtL2E9up8EoPcmn38BwEter7flv9ak3wxfNeBjAExCCLHmb8ny5yiY0AMACCEMACIBjMjvJa75TKz9/fcMaxe3aZBxpqz5WzIoE+AdcgEV8/cJN9OJt7FWXvB6vf/T6/WWA8gHkAW6y9MAFgHke73eMPnP6PV6g3/XHfhtwuv1vuD1ereDMvEC+Of3cJtf64jMpSSCcvYleP+Tv82DCzaAXxcDrF2sh8Dw02/CEwAeFkJ84b/SyJvBVw14NQAPgD8RQvgLIR4FsFF+9gKAZ4QQJUKIQAD/AOCa1+u1ADgCoFAI8bBkFp8BEHf7m3974fV6VwC8BODvhRAhQogUAF8C8Hbd70sAPi+EMAkhwgB87Q419XeFm+nE/wMhxAYhxCYhhBacxC4AK5Jp/gDAs0KIGHmtSQix97b04rcAwf0Cu6QcXOCCtPIeblUuhHhUzqMvgCG6q7/Fpt4OTABIu8nnXaAXsl/qwtfBHMrbeA7AfxdCZMrEd5EQInLN56MAdoN26tO/7cYDPmrAvV6vG0xEfhiAFcBTAF6Tn50G8FcAXgWZZTqA98nPpsFV8V9AFzoPQC2ofL/v+BxojPoAXAKN2o/kZz8AcAJAM4AGAEfBBfK9TOz/73AznfgNCAVlYgVDLzMAvik/+xqAHgBXhRB2MOGb/btp+e8EgQD+CfQmxgHEAPiL93CfN8B5ZwVwAMCjXq93+bfVyNuEfwTwdRkKe/ydH3q93jkAnwYN9Qg4f9aGXP8VJD8nwOKIH4LJz7X3GASN+NfE76DaTfzHMPIfFqTrNwzgaa/Xe/ZOt+f/Fwgh7gPwPa/Xm/KfXqzwBwchxDcAZHi93g/e6bb8ocMnGfh/BUKIvUKIMOlC/gVYWeBrrt9vFUIIvRBinwxHmQD8DYCDgjtuAQAAIABJREFUd7pdCgoKN8cfnAEHy756QRfyAQAPe73exTvbpDsOAeBvQXe4Aayf/us72iIFBYX/FH/QIRQFBQUFX8YfIgNXUFBQ+L3AbT3r4stVm7wAYMrNlA+34Pwyy0lTY1mdY/O6AQBzjjEAQPTgArZkMLl9JX8/AOC+V2oAAD/wsIZ+d9K9AIDCHgfOu1gOvrKD+zbSxBwAYD6Q5ZzTodFIvcLy8fG9LFudnmQZ7/ZgtqX55EG0F/F4iAMjUwCA4TAWqpy4yhMiXbH8brymGavhWQCAxTQtAODFv/nF2vr0m+LZL37ay3a1AwA0lUnoGrMAALY2lQAAhDcAADAl6gEA6Sl7cKy1EQDwwIeZ9J74Ww5lx/0xvHaG7b6/1oCxu9gcNzoAANFBCwCAzGUDv3O4BCPb+wEAOb2MJtXsmgUAlHfL4zCOhOPC52wAgP82Qnkdv/RzAMC8ie30JPPvQb0ZMD7exr99twwA8LETX7tlmXzmVz/1AsCmZ+cBAP/88WV8ppfyT5ihbFoqOVbRI7z/QN8mbB/4HgCg6wtbAAAN4iQAYP9iLgDgpJNyzKsJhF9pJwBgtJ/9NBrZPL8yI39eyIJ1mhVh+izq5OCwLMpJ5V4PZ64HH+5h+Xz/UhgAwDxOnezU8tqGUcrElA0kRVmlvHi/L1V97pZlAgDfePHbXgAwnmfRS5DTjvNBnDf56dyDkx1H/Q9N5a1rOmLh7eKYnjHx514n58brzg0AgIe0vwIAaMV2+GVSD4f8WN7sP0EP3WmaAADoLMOw2fi9gHzKM1U3DQCoG6LOJWREQBzieKUk8fuDRdwzZa3mXp+nlrm35WSAF8EZ9/HanFoAwEe23XvLcjn9d/VeABhL9QAAGv2yEGV+EQAQDc7VuSGOgTaa8o+Yy0fzFPtjaudciH28iff7PnX8/TtD2adRLXZlUabXxmN5n5U+AMCoLZ79LUnBqdpBAMCeXNqFOT3nZfckj2i6PygUnUns37+P3w0A+FwQn2koLODPnusAgNmj0Zh8hPUDYZNs55cf3fOuMlEMXEFBQcFHcVsZuGkjV+EBEzczLU8AATNk2gtBXJmDToYDAHZutwMAVhYex5DciZrXx9NSrzgfAQDsTePvoZlc9Y5kGrE45gQAPKXhM84I3sedQTaXfSkIYcnstrOWDPToJBlkWDpX1t6YPSjoJ4M4E54HAPCskqXsSCPDXRiMAgDoKvfgqpuMrND/xrpl4oysAwBEbeRhbgFvLCNewxV/MIZ7k3LyyBKau/mdAdvzeCKXB5u1/4gLs2NrCPs3R3al6yAbGi24C1rXRQBAqZts8ZKHfZs1kjnlFY2gN5VrubOdbHVHHT+zZ1+jTPaWQH+Dz/inWMrS+MwTAICp69wLkZD4OgBgXETjvpP0suoyL8ie3vreIE07mU3dU2zD/a87sfwI+/XaEvddxSxUAgC6eslmSz/8F7gyxrFxnaTXpU83AwDOTlA/livIoNq2jiB6kHLrSohgf0PJ0gZaqH83AifwvrhmAICnl6fxuo3386ffZQDAyJkcHE2lLAcbKaeSXD5jZor3id/lAgA4tMM42VoEADBfkdOu6pZFAgBonyeDTLmbLHnzaCASHZRV8CjH4E095RQ2x7HqPu/GwwUNAICtwWR6C3KO5OTRI5urIdtc3mBH3jBZqzGIeulnpT4YmyjTpQQjwgbora3mUg/0TTyCPjeJMp12ByIujnNrJI6MtqqJY9OkoS6fTOZzMpzzOBnN47jPD3cBAD6Ce29ZJqPvp3wtz5LdbsgswnV5iKLWRU/dq6e3lrTK/r/48ylUPU1ZziRRBuMNtD9iJ73p4zfoOWhCvHhtjJ5YShf1YHiOXlboh+h1uebqUeWg7ZgZ4rM3GWh3BiPZvt7zI4hIyQEAfKyCz3RHUya2S/QGQyLZPuu2TkRcoHdTXXrzrRiKgSsoKCj4KG4rA29dcAAAUgbIEq6IaSQWMdZTNsEY9eEkskXTHFenlIXXETTKTXPj+WQeScknAABDyWQZw6lkT1uuAu4U0tSmWrk6RjJuHj5nAQBkmkcx5UkFAITUM/75ucIZAIAnkWzbgpcQHcq1zT+SIvK7TMbdFkdWePk+so9/uBKOqUyuugv963+DUn5dOQDAXsNYrivpJVhzNgMAktsuAQC0oWQ8G/22AQCu92TjdZI5bAxm7DPVn15Kt5OMyVBKhj5Y48GBKG4eqy4gc3zgyKcAAANh7FNTzDG4Xr0LAJDrlUx8mGPVmUz2orkRhrlN/CzbSDZWtkDGdM3A+OPls4z7leTrYa/ieHpm1n9MiDGRMs9q4ncvbe6H/dA9AIDZvzsGAHjqMsfZEsBY7eGmIOTqpedyhfmBBD3jhyvBZOulLRy70dlADMWwrQn1fFa/l96Tq5iyf3i2F5fLGQ8vE6sAAMcI9UUkk7FucdmxskRdCs0n4zJbqUOLHWRQaVrmAmqCgegEys81GbpumQBAmpPjtaGL3z/q34u0gkIAgKGGz6uKYps76njMy4PFBWizkVVuz6ZX9otgxs0/tcQ2O3MYpz3rN4FfeRgnT9HQ+4swHwEAJGgeBgAEeq3o+7L0ZDoZs6200IuOn6P8R4wzmEumV2rTsz3HFviMxUfIto2D1I+t7To4z5OlxhfErlsm8730LoLu4Xcv915BrKMHACCs9MIvDNJL0uQyTp3zxRGEX6d8OmfoweVlMTqw1PqvAIDQBf5udz6BfP8rAIDpKcp9+AF6sg/WM4bdORaPpV30OBJPcLwHNLQFD41yrkxtvAsjc/RGTUMcR8PpVfl9zjW/NNos4dyH8Afp0d1ziWOG+969/7fVgKeEcaAW59i5iog4ZJznAPfq2eAyF8MZIz1UgKQtMbiqPw8A2NROQ5uWsQMAoEk7w++MMPzQ9nATygb5fWM6haMZPw0ACE2lq/yWIwYFs0yKdlc+AAAoCXoWAHCsSd4/7GkM66sBAAGXOPmXE6U7ncjB+4qFffmJW2DT6zQUC8/UrFsmHR+tAgCIqy8DAPTGR5A4R5eq10SD4wqkSzlvPcr2mcdgrqY7NjlI476wkcZ9LJAul2mCbTGWDWLY9nHKwMlrrzzxBgBgfIDJvkhdPuY2MORxuI6Lq1im25g2zzYE5B5HQuh2AEB2AO9zdYYuc4CZydvHnFyEcluaUd/N7weY1n/UTJH3HADgYArd7fQWD8b3cNEO/w71pT2NLmv1HrrCCxc3Yc8SXdzLT3Ey93RynKtWmdRq3cDk39bLSxiapsELjqYBXmrnQhDR80MAwBH/AnzgIg2d3UCdijMdBgAs+7Gf6dOxOOdg4nQkgaEM5ywXlrgy6u9MIo2I7pVJFOp/AgC48tSfrVsmAOAu4OLcMMp++nVNQG+kEelOJBEK1tAITAsa14LtMSg8RJLQ/TznUVYeV/82Iw14RBhDkavRGmz2csHOv0I3fyCWOjJrJVGwatJRfJFGOEtHo1xTxgU8IJSEKtHqhqfeDAAYLucYhju+DwAI+yHDbrPx1LPTqUGw2nmf4LabnQv17tA3ciHQV1LO4xUa3NVHQtU7xv4WXuSiatvFa+deGEJfOOfxsWISsQUz25PvZnjWb4ALmTkhCy3NnEs5svgirpqLxrE02gvThBfTEQxhVfBPOJJNm9BQzNCMn2UBsVouAGFLlNNUHBdHZyFtjHWRC8XidiMGztDwL05E3LT/KoSioKCg4KO4rQzcNUR2kFtIttLsGEe7iYwqL4huxBUdWc+9g2S4P5qrQHopVy4ncy8YGCMTFVvo9vvXcRVNcn0AIQYmH4ZiJwEAq1u5MhvP82dWRC10r5Ixxj/BEMWAk+75chQZ5dM4gYMnuFrP7GJoYmaEn8Uvk+GWdlkAAH7+CRg0sg8r5+Ubk9ZxZE2Q5TgAwB0oS7PsbYge4TL+8k72L7mHSTh9PNnRSmgA/IyUj0HHFX6+5BCvXSATTzzP9s3m6dBWw/LDR1Ppjr00bAYABBrIqmLFDLQyKTtaRgaZMkBGsbRAZjK9dSMSHQwhNA8zQRcwSuY0fVyWJ36SbKHzWjqCpvhZ0671Hy0+MkvvKW1Uhq82ahE5y3uHmvjZ3AX26R4rdWpyAPhlMvnIjnSG38KdZH+eVepbYj09taHGVeg2s12hIQydrJgozxXHZwEAGalu/CKaXthdHjKu2GV+v/kcQ3kueyOCEimLGJkQNvaSXdXOU/+K+NY6dO/ORvwiXflNLfSA8FjeuuRSeZFj0b+R+uDIr8CJOur7R/P4nLrtZHH67/GYknNvvgWnYCgqJJ0eSZntNQDA1VHqa1EJxyq3oRAjbh5Q2SDoOc24OPeSdfSaLalXoR1jqESbyzHJmiRbrbZyzvzR6iDOG/iswpOca3GPfAgA4JrhfAqppe71GtIRHMf5O2KbXZc8AKAmnM80vCHnwwY3Dk7T+9i9xLkQfD/1oOUV/j3p/aVwXKLn9dnz9Lgal+nBlEzx2sYsznfN9b9GUvguAIDTRq9N7+D8DNBx3rcaJ2G8yn6eCOVcWCwlq85tZKjGL8wCayrltnSE966TYdCtLgsAYGCI8/vuZz0Y2EhvZPHRd33N7a+hGLiCgoKCj+K2MvANoUwMfGeJq1J6RDbC2smgunaxKeYhrjgn07niPz3Xj5QaxjQbbWRfIzIxaf4xmdBkJllIltuCFTdXt/YgsgLLAFlO2n1kLZsuZeO1snwAgNHI74cGMQmzt5MxwWvZEYgo5go9F87EX0II2VdUE+O/ZxLIfNta/RFwgGwj8bvrfzFLwTjZj2lFlsl1D6O1kit17CWy/bI4xvKWJsnS/fv08EQzgTgSRvlF9pgBAB3JZAeikEyizzmE3TpuHHjNzth68cJWAEBLN5M67g94sKWd/58JJqP0CyUjd67yp/HFOUxEUJZzdzEebc3eBADYeb8sWZtlPDbIsoLUzUyCxUz5rVsmllXGqv2yycieOrmIHz1ENhzdQhmMhFP+Q9fIQTJy4xAeRIbV/0OZO0jluBToGRMddzNBrnsgDFFWXhsXyfitzcu8SpzME3RH6RGxzGd0D5BpeZzcGDQTRuoUWjoJ/xfJzsJHGPN0ZfN+uwc5DufG6VHmBruQN0FPwLInc90yAYC2bMp9uInljA7jOPL8Kd/vlpG9FT/Pkr4V1/8AAGzL3wOrzKn4CbLUtmDG8Mtt/M5Azwvy8zn0ZXPe3WulPLxa6W0s8WeFnz8sYdQVjYvy2Si9t6QMepPTui2IWOY89JRz3vV1vAQACB6nDCY30xupa5/BZzxk+ac1J2RPN9+yTKIymQtpWeWczrz+CjaFMbe1kvtTAEBTO3MAGx6nPjm662GIpVdyPsIMAND507Yc7qHdaNvKMUq6EoSgJc7RzS6evjyaRb2KXqanlxBVAdHBdsxHPsbvV9PDSLrB58QtdSHtAPM1wXp6wokR+wAAR05z3hQk0JsYKb+MoW7aopAmWVK5/d37rxi4goKCgo/itjLwgSiu7p+oY/XIIXcKEkB20HKKrHBnLrOvm7sZX/N/zIj2Th7V7bQ8AwBITuI1K3aWAMXGcQUbKCxGcBvvs2WerNywSIbqfYHfOZK/AkPFmwAAdz+Z4+gE46lF+xgzG/fUYbuFMSh3Mv8208NSvPD7GC+faWSs66GkWJw9w00Pi+b1H2qokX25kUcvI+DGVthcZG8fkLJ4PYRM6f4GMsEfZXgQa2DMLlbDWPVMOzPa+QG8NiOFZU0rr4yhzo9sPTyezHZRz2SC/o/4zIOv65G0iexsWzXvd9VAmdiXyKQ2PpYKTSP7l9hI5lU+wfhx3449AABDMz0szQMzCAhmLDbeumvdMvnQIpnuy9oHAQBHcvqhsbA/5/LeAgAELdJDSsmkTE6daUJxDuOQugTGt/tAz6NZbsjZZSdfGUtaRmY0vZzvRpCdPWFkHPbUYeZFNnbtgFl6D67trLpAEuVnD6JOHbo6hRIXmXxYIjesxA6yv+5SyiZgXB6pvloLWyE9z6jetS9tuXXYW1mF4ueQm3XsGiR76RkutbKqYmEH50SIk2NxwU+LGAcZsgihvo/3ki0u+lF2aVs5ZzZfi0f9Fc67ro3UB6eNFRhikdUZkb2HkJnD+G7ATylv+5fo7Y20sV2JS2UY03JOmF7lZ+YSzpslWa4ZNSNzGTPLuLiDcs7s1q1bJgF99PQSpSerX9yD+O30hl6bohcxNUiPLM5GT6wn3YqxQebRcs1sn2uAOhNtkB77RXocjoRFnPSw5DS+j3IyRjIWblugV6jbNw3rj2lKDX20CzGR9Dx0mZx7Y95PQYRyTukT6GGMOC287w7S6xsGuaGnLQmmUM477WK97Om+d+2/YuAKCgoKPorbysC7Mri6X+5hhrskxgrNJBnfhw1kXacDGVedK2O2evsbIwjpYRyx6R7GMGMSyK5bo7j1NFxuKGnt3IuPdTP77yjnqrvzHGNJNUHc/mosi4X2NP+2UUsm+mIFmdVqF1fjbs0OxK4wFl/zHONzQXKDQ6Sb95nMI4uyigFEpZMZebRvv1f51hGTx/tbGimTXkMLymrZrtdiyaYDQhhHOzFH9rLPtRn+sWQIv6hnzHZ3ujzgKJrsathOBuzddi8W3WSHWwWf1a1lXwJeZ0zw7owBRFu44veNSoa06aMAgNSr7G9sTje6slgpNBrMeKNpgexy5TBr+BMLGMOz+G1A7A0ymre8YeuWyZkKMrmkI4y1rs7bYWtk/zbeT7m3hlFe/vVkiqkJ7QjspS4F7WQcWj/NNux5kW1YSKMHqPcPwLyejPtvprnpo09ul08ZZH5lKdQARyj1ZO46Y84GA2u+h0p5zcfnUzAVII9PmCdLC5wgE1yxU546cQ4A4Orej6mgX/DSyPl1ywQAZgJljb6HceQJazEi46izF93cR3D/AL22M4L9ue/GPPzlppTGj7A/eS4yaG04N50E63ntc1FW5ETy/84VenReDytVAjYybjsUnorIN/iM8f1k+2gkS9y7wt0mUUst6IukrLOiKY9zNrbdL5d/H12hR1tW1gXtKcaGAyd3rl8oi5znRUbW6Gsi03BaHiDlfYv643iIG5kaurjBa8d0ME56qDf6Gcaxl6zMa1i65IFX9zDv5Dm6DTtX6WnMmGmT+uUmnWV5uFVppxOdYO6h2I+x7+QI2o/cWnpkV7/YhsOd/NuWOHpNiCZ/7uumN1AkOC8vr66gYob196GVN3/b42014EljDHUshXAyhq7q4Ainy+qIoVsSaOVAp8aYAQAXN05g0URDlhjNDi51s9nl8z/g7/LdAysF1RjRU6j9sxSk+wEanfyTdPPbTh3FsvkhAMAL7n8HAOyekOdqpHJhmLY24UgXB3jfdi4Szmoast4qCl07RSX2j4pHyAzdpokQ57pl8mo7E58hLipS6WgWdAl0P/dpqUx9YzRIA1nsW1dMDeKvc7H4dBYN0KsBnBCbR3lt/DB3zgW8LxipDTTcffKkvEQnF7n+u2mIsobHMbtCo2DL5yKbLc+dGd/B+3pMQPQgXfD8Grp6x/uYtNq79WkAQINcEHNd7aieYYgjMNm6bpnMu7lgd+7irsuE5khMpNE4a6Y5ro4I9rNBnuy3wbELIZsZ6rAEUJaVqzRGgYU0PlrQ2DbXOBC9n6WBh04eAADs+BBdXnsyFzVDdDdCOqivujnqy9xZTtIDRvape8GBkl2cYBe7GHIbfpghlSi5K3VVz0UtXRMDq5GLTtjLUiafWZ9ctguGIZqHOA6bTYuojqesnoxhmGRMw2s8/tRJ47lhzN5LmW17k9c2uJkcDxljWMpRyNLRkoJSBMty2Sh/liEaw7gIntTRoOT2n0CAzMHqYmgg85sZWjiZTfmGVA/hUbmpp2sf5VwRymu8hzk2JbMW/p6cgZpktmNfydT6BAKga5j91HY/yvuanZjcTp2ISuB4bWuQpYEJslRUN4s0wfGKkSdLdtXy2eGPkBBNNJGUlZUb0NtEm7RSIBPFS3yBV0CW3H1b8xFsuJvz8IqLi3NvNReRqCLatb7RDDxip92qmZXhtVbK+ouZtAG/cHPOvD/0LII2y9MM6//DKzb/H6gQioKCgoKP4rYy8PBOPi4glIkRjSsWFUNMQgzYyN48hWQsU1ayxr3GVDRkMHGVM8JVc3JKujkzTFLMJcrNAe03sCKD/zMuMrQQeRZyYy9Xsk0BURjsoytV6GDyQO8lI+09ynMlntiox7Eonqw3oOPKnp9DhjZVyzK72SwmVmPtOpwPJdO7S545vh74yahLcB1dttCYNKzOk20OpZBJTHUwqRlvYPigpnMO5d3sw/FH6Y5lHpWJoEG6xSdy6Hkk9VmwqGPp3eZFWdoWT3aktZJl97vsWMpiEsy/h+GWyy6yog8OU37PzZhRFsjG+ofzdZl+uUwSLp8z8/ctTNLN2fRY8qPbWjLQvW6ZjB+ky6/Xs/+esXTskmdBOOLIaCZl2WWhTNAVVI3jlzyeHB94khugLsdaAABilDxl6yQZdXFFLi4KbumujGXCy32ezDAwhd+pc55Br/1PAABfT+azZnaTyR2KI1OK0DkwPcqSsjDZvolTlGlwCeUXVs9EoUg4iIVFenPZEfZ1ywQAzl2XYbwielLDAdPwTlI/+9ycL1E2buh68N73AwBuFI2hcplz7Ada6sSG+F+yjbJU0NxEdm0IacepcLoF+Yv0JFocbH+Ynt5QT6kGRfJkQl09n92QyHBLbAifE1segJflUQKaNo5P7FEy26l7ZQL1Lc736NRNCO1luw6mMAzyJB69ZZkUdtKbv17xTQBASM+jmDjO/mge5lg0tXMT0caprwAAwhfHcd39ZQCAy85wSKTgOSVxqwylnAulZ5U6OYKSUcrg/CpDmUWl9ISrPSxw0AwdQ93LnBtZlWTiOX68pnUD51PF+TiMhnFuxqeZAQBLfvz91Cn+nhZDD/JYjBWil7oWF9Z30/4rBq6goKDgo7itDDyvkPHF2U4ySbHswuk/ZbxX+00mCrZukKff/RtZt+WJZ7B3lozqZTeTJfFxZMwXQrmKf2CBq6ZwRGHIzHsHBpAZJfUyvj2xh6vdSxYPZBUQ5oPMAID2fv5ceYbMvuN8N5LmGehLt3BzQWcmGc5bIWRBf3zjwwCAg+nP4X4vExURP5MdvfWjr5FlkXHJQiYEy0cM6Msjk11o5aq+PM+2Vy9SRmlx96NmB0shbZ2Mp/lHMmY3mMS+eKcZpzYGrUB/g+zJk0Y25NXQiwiUJ7Cl16ViUMbFo0rpuaSmMPG3eIzX/Kn7BHpkzPR4AJNND5dS7hMy/tdzSr4NKXYUJYNkz6vlty6LtxEdTm9iXMtSM2fUDGLOSA9okPrx0JeYuD4ht3j3Xr4GFLOtzg62My2bnsaInizGLuiJHF4ahcbJOPB5B+O4oSUsjdw9Rzn6NzgQ7/4JAOBUMOPknl4qTvklliWGF0bgedBzMT1Llq4tJ/u7KvMWW0LpHQ5lZiByjMx1umr9W8YBYJM8G7ozV+ZGjiVh4j7GdRf8GZfNm5HHThxnqe7+xe24XsB58hUjp/uim4UCh5OoB8N6FgdkdEbgochv85pu6qXYTibpamV+KMW7jIlg6lHXTso1pYberV8wvZlamwmbLvKZTjfHYnW3TMifYh/i8/idkZk+uCf5mdVJNo333bpMRp8ks9+2TEVrMAVjpIlHBWwa4Vgmm7hdfrCTc+yV3eEoa+QYbnaaAQBzZupK+0Gy7ZFoni8+ZDRgvIh9T5Y5uJ+/7Z360aPTBMeiLJheVU8HD44riuThXVGH6Yleim3F5lR6zdFWzpOjp6k7odH0vsO11OU9oYuY7ibb/3YIx/dvf0P/FQNXUFBQ8FHcVgZ+ZIhxnWAnV9+uVBM2/Iys5KVlrpa6FjLyqWIW3ae+Zcd0DMvUivXMKusSyQ5XB7jiHw4k6zasXkTfLJnDzhlmvZsrWGxvl4xAJJug7+NKenaJTKZEw1XXFcwYsd+mCqT0cAX2ZDA7nXSebHBjBNvuNbACo6BvG05/zgIAKKpd/1b6U7F89qZhtq/JnYnZGyyNcsiDcCIqyYLMnnMAgPCJFJhSybAX28kOA4YY35s0sfxvtZh9fKujEvERzIwnJ0jG7SATWBhnqeEwxjA4QTawr5vVKye9rFxYTGAbRkO2obWD/dQ8SOamn2AsdshDL6BSllbmHC7GpIHM9vQK2cv71yGTsFXGo7OjKIf6aANGQ8loCzP5jMHD3NiQqGc7w4JzMR5KJtl1g+PgnSfT1XeTp7gLeY8dWi02VVN+FwzUycmTLOW6HkeWZk7fhsQSsqfrRxmjjY1mn+wh1ENt+hF8vp8VOGc+xCMXPBFkpbGdZgCANYPH/g7PWJEmWOEjidu6cWyZ7Y8aYhlnYXIAnA0ci4QselAD7czjuMplFdZyF+KbqMMH9exbjol5k8Ve5qLujSOjfjNGYOcIK2W+b6bOOcGDtz4XwnfEntKNYWqafQw30LNLCWAuJFVWeRTW2XAtlnLV2JkvKFyiZ/KG+TtsZxCP6O2KLUCRk/pjHNOuWyaB1xirvm5g7uuPS+fRsYVj29VBVqwJoR6JZW6gqWgD+kG7MOSlt/dkMHM1EZs4RzbJdwxEBTwBh9xY5rBTTl+b5zheHKeeFT/gwalq6sZD2bw2ZIn27EaMrFRZmkdjC3MEjxroLQWW0355BG3KCocSbZZyBLfxfn9SMHPT/isGrqCgoOCjuK0MfNssGcSUg+wgRuvG2CiZbWIiWaKQb6t4+72VIZk/QV8vs+V9V7nabpebVSxbyFrNlxhvDY+KR56NrHBJw+/HX+Aql94nNyj4j8BYRGZmbmDcy3EvY3CZV1gL7Rc1iJezGVMLE2yX6Z6fAAACnFzFO9yMAy/ZWpB/uAoAoN9886Mf3w3LYMzSKA+Cmg8eRrlZvgF8nG1u9ZBB5AzwTToT2f0YWmA8NjtK1ji7GCWLCWWrj9ATAAAgAElEQVT23+1gTLfQmAxjBw8r6i2hnJZWyTJ2JpgBAFfy9Yg+zlji9SEyrswoMqirfmRXRXMrmEriM/N/THY2+CWu/0lXyN7HlvlzZOsS4vzI8gsWstYtE0M8GUldvnzBht2EKUHWa2giGzZWUZeubOT43DfiRrqT1TsTh8l6VzLltvs8xl2jW/n5mcExXN/FHEmp/1MAgKozlNtCEGPZR9tn8YieMrAnM3ae6mGsMuCfzACA8ys27PZjG51zZGxBdnqAs/70LJdtzA8kXvTHyG5e0yO9rs+vUy7xU2R+1iw+c3TRCt0e6vLuU2R6s2wq3PKlAYN72hGlZ7VVQgv1KW6e86/wwU8AAF6XFSK78gdRT7EgJZr3tccwLn2sl/oZ3OOP+1Pp3TUtfRgAcD2NORpdPOWVt38Stnay/f4qVmFcOsXDtaLL5CFxzaz6KBjahCV/jmFmqWmdEgEWT1MHp79I23D0ih1Ro/RCjAZ52JSTh9U16sjMEw1ufH6JY3Elh58dk5U6fkFsw5Tc+KezNGBBzzbH1VL+I0v0tqxyA9/40HFkTrAPlgVWLoVo5P6WYuZu8vpTkKaj3Ebc9GbyvGzDpJHyD77GzycizqD2HtqkDd3LN+2/YuAKCgoKPorbe5hVJhnuqtyxODHoj4XtZLLxC2TVc3IHZWytGQBgjLoPQSZ5EHoFr/EMcHV/dILxtL4SsuLui7kIjSTj8Qshi7WXMNYWLd9I3j9zHWYbGVD3RrKu5MOMhZ/L5optt5lQFv0qr5kme2nIZm3qbDvb8pSesfpzsKP+FONnyY+tXyaGJTKbPlnb/qA3EBMjXFfbUhnXGzBUAQAyNKw8cQXGwNv4RQDAARPjkM/vI2Oa0DGGWSzjddb+brTvJqN12Sl3q5us/dwK49sz9iwkzcjjCUoom0gtGbxBblWeHwxCfDRzD+OVPI50/uV/AADERjFfURLNKqF6SyjGssgu0mUV0HqQfIRMfmqUlUCTK02Ijaaqnk5krb3JRdmUt3Kcpy7OwRbP2O7mu1mnHptVBQD4xRjZVJ+e/bUEZKLYIt/ZOMW66f6T9AST/owVBgu9vZiwc99B3ABjxaFD9ARf+iO+pm+vKwFj0WRIaTbmDiLmvgsAOJFOD+EuecDWsDsOg1PSG0wyrlsmAOAtZJ9j2tjWVHsG/L7JfhyWB7FtlbXmYp4xVL0xFv9LvnxkVyLH7cVWjlPsCTL5p5c5rtcvHYZ2A2P6moscg8BsttU8TxbaaRIYPkZdsdkoz7IcxnQbdGT0I42T6InhPNRWs30t+WSrX77Ew6KOR1Kv/AIssA9yPlebTsqeHrhlmbjC6OnF9vLY1cCueqxs41yPH6IM6jcyuFw+RQ+yfsiBw1aObfTwOd6oiId1zfizXQ8NUmc6hvciboFeRFoR8yRtsZxH22/QszuhOQBPNHViOpH5uioD56NFvie3yz6KDatk45fKaDs++wPe58eP8fhbxwptwJaeSlyTB9B1OW6+k/m2GnDdGDsT0EaF8QsZx2wEXc3QOIYSNnVSqWqLWKI2MzCJuS6e+1FyL5Vp7hCF9FIFLWZ+I41V1AY7bE4qlz3ZDABIvsbJdyOG7tOqcwAjLiZbVv25oPTn0yjMH+VAbcwBGmbphpk8HCTjz+VGjxwq/y9zadjLz2gQn0uXynUlZd0yyZpiP1dkovFEZhQATlD/4zKsomFyrtMp32jUGwFbPifzAcGJkfUcS6fiHqGxtumoxFNLXSge4bZoe8o5fiZfGG0L42S6cW0W8Rl0JcNbOCmnbDwJsCjiVwCA2aTHESi3rfu/xDE68xDd1g/GMEV5elC+vcgwgKcDuZW4M6V93TI58gw3kYRv4ISLrw6Hxcr7BYVz7IYcTCAttXJ8VpIG8aQfF1J7BBeUQz+ia7p5L8dlUW713zodh2saecbEhAUAYP0QdWmhjZtcSlNakPQjGtxX9rGMtV8nT7XrppHvejIG1wc4VjvsPHt6GGxnSgkNRM8Qk4vhiRnIbJXExWRZt0wAQBfAMZ/r5fPrIluRaOZY7rZz3K87WR4Xl89nFZxdRKjBDACwtLCt4bJkLmFRnvWeT1kEXrkf4S3cTGJN5sLjTWbyMaWWW+LnKvwwmy3fcmXi9/WNDO15vQxZ3YiPRfFmyiz0+yQY0QF8RpvgfIzUk1hNFBgQ+i3KLKmzdN0yCYzjQpPYT2MdFBqGlRDqp2uZJCJylc+OMnHzVkbKT2Duo4G2yzP2s6pp5F0Z/PuC1K8u3UEEZZNkRnr3sk/XKOOOj1H3dv58Eg3+XMhT5Nk/thYZeg1nwjkh7E28WcwQnlEeyXB0B7+jDZbv0i3gItltm0aoi2MUpbv5i9JVCEVBQUHBR3FbGfh4PEvAFrRkee5AG6anyUDjUliWZzeSudhnyebOFpdiV64sq2slI7uQTNZh/DnZ9kgVV03h8MIzyhW5aIHs1Z7GFTDanwkWoz4e9fMWAMAecGWd7qbr5tzL5FfLfB9M0jNYfZNMIXQXmVSMk15AqIbsLtoPuJ7LZwTYG9ctE5c8FW06kow/pjMYs9Fyk46ODCLvAbKr8V8xfOONb4JY5ulzm+1kVeMfpQt/aYpMKbuLyb6uoHDkJZFFu4/wQC/jf2coynGWbl/oRypg/G+UmzOQ3ysp5c8LPWSmsxvH4fg229FXxBDMg46PAADsNUx8Llno0ZQ8bkf1BMMfEX5j65ZJ/DITgZWNlI3N68apSDMAIGmV3lfMAt3RyCz+XWfyoKeZ4aPFcIbhMtP4+yEn3dEVmdgOi2nHdBBZ+RZ5+NlIJ8tGnw0kW/tQZBW++qQMA01zc8vGP+KzVn9MXWquTcDH7NS9K9G8T7bcGORoYFJx1Uxd92/eg/APSJ1sX3+yDgCmZsj4pg7QBa9qKUJIDdvS9gRZZ9nzHKN2YxUAYMihx7wM6zwUTrd+WJD5eUE9WAih91ux2w/H5aFcs4Vk+cUn5duW0hmiyXFM4sUd9HQqf8ik27Ui6r/ewp8ZAaPof4UhFKP0Gv2iKY/zV8i2t99gEtMUl4PuDbQLnsLQdcvEFk2v2eSWb/YaC4d2jHJKmmVRQcfr1HvN52hjFn5ciXAPw2w9SQx1pZezn21eys8eSTmUGBLgSqFXprv+dd5H2pvZ5zgPhsN7sdhHppwh5EauPHrNmhHq3kvuXFSdokeXlU2bYujlOFqH6clMd8h3g8bOYUeMPLhuquem/VcMXEFBQcFHcVsZuH8E2ZNmgCtk+VgirmRyq3pcMGPUY4JxWe1WMvMtQ15ktpIxBGSQie9/nb8PfJ6rZ798v1320QS0V5CVDwaQCUW2cyXVJ/Is5kCDBoYxbnft2/wtAMCuIMbr3hhh6WCxNhbTU/Lt8ylkeq88x/vG3E3WoR3laumMc6Nwju3w08WvWybNqWS62TVkQzNmO7wesvzoRd538jl6Colx3BI8pgfc8rjOPC37PjVHD+HAPOP59igmIe+JbkX7NbKD+Xsof28rmaknlgmvnT+fwpECyikWZAO7usjWjNNc452WUWgMjIsWbGVp2eBFCwCg0E1mYSigbG7Yn4afHxlOnlj/5qaFWcq+z0ivZNq1ipJ5JhtzkihjD4ktVlbocVw4no6cbLJG6yRZ6VAYmWKUg78vVbJPAd8aBFYot/lsjuOwnQzugXh6easzHqwOcTt6zhRjn32hPOBMZD/OaxxLaIhmvL0gniWGEVrmRpbtHA/zIJnUeGQtRn7AthsTxtctEwCosPKeiQtMeg22n8Slj8m341xmfHxSblx7/zW2Z7FsErWx7Furgc8d8JABxozKksyj1KUbg1YE7WEbgyckM01nLL03xgIAeLEtErsPscQtppzjvVjDOTLyhDxO9tJurNrobYRkM65b30F9eLiIDLWviX2Y9j+GCOkZZb5JTxEPfeOWZVJuZ2mkNV565TlDGOrhuJmNfMbGALbz+g161VtzahEUQo9iWia+75t9EQDgP8B53pJADzspeBJhHh7Ra+ukbKdc1Mv7c+hxRzZvwQsPU/f6RunNhy6Qpc/I8tJ7H0nA+dc5DsJDdu4oJtt319CLSM3l3AswGTAs9SZk5eaHwSkGrqCgoOCjuK0MvNqPzLlKniY1MNqI9B4eBNUTSMYNeZBTUi0ZwHROIsa6mfUNmOL2+KUKfubwklnm9rECw5sdDb9Fsrec4/Kt6vtZUD93jsXzqyUe/FU247LXTjCG21PzCgCg4FGyOdNsERb08oD8SpZBVabz4Hh3P2OnI24y3S6DEbH1LPXJihbrlsn2GVZpWOMYG1xypmPAQ6abVMxjOgOWOUzR7WQCcd0OHNSRObbksH3x4yxx6nNyi3n0Fxkv156bRqysFpk4zhhjmnyrtmWM91hZtuCLghnyv5wjK389i7JNWmBlQctwDGJzuCknvZ+xv3+Qh+JPJFA2T2Tx9x2Zv0TIKZ6v+kYW49kfWodMwiLICJ1DZB8JA0Y0J8sD7hcY828IYf8yl8iYFvbpMDREhu0dkPmKT/Fn00F+N/N5VhxEJgUjII9ttlUzNpvWyBK79iR5ANJ0He63k42GV5IhNctTljKa2AZsykLEApnujHzj/GA38wG4m/rmNtDbyQjSItVLPRsM3bIOafxfrAZzjF6eYaVIwhNRODDOCoYaL8c2sJbx5NejyOC8ljCYE5lT8bzE+VO1gbmFbrkJqfZefmfDj2YQIo9svhxJNt3QbOZ9dzO+nTo/iMAMWYWTQnauG2fVUIosgxtOs8PbIr3SAD4jyEGGPPoWvUvd3azcWm14DLEdvPds4TfXLZPRYXLQ0DjmzDTBAqURzAdlhLOd35riGIgIzvslPyd6ztKbT31/o+wnvUpLMtl11jhtTv9VDdK2sZ8GeaBdWTZtwOFpMvq43GPQOjiX4j2sZvnXXMrxr+c4lztOTiMniNGFkBuUic5B3XMXyMPbbHLbvWse9dNsV5B26037rxi4goKCgo/itjLw7R1VAIAVq3zjc0Ut9E5uXY5fYazUcJbxypVPks0GfuESgnabAQCXn+CqXnmFG3c8C4yL+o8wJulJ7EVuBO/dkMqVcGMxu7iplYyrfS4Z/xDHWHBZCCssLHdxi6zhClld0G4jour4fbudK6s/CTkGohk/nPEwXpcZUwVX0duvSmLc/al1yKR7jM9OdfMB81FX8eR51m1f2M+ac40kdZHbmCfoaQRSi+mxdE0xs24O/Crbk0gvovMHlGuNMQjGSLJD7XYLAGD7GBlu/2Z6O+EjRgxV85rMJLINxxG+HWHSbWb/y2y/fkN2xxTjvrluyjQ0n2PX7iFDdGmvomgDWcbDA+v3SuDmOBhIoFCd+xOkaciiIseYlfcYyNoWFijt3NSDGB5kTFfrIUOOtZApDevJOPeWsY69xd2PufP0JmLuIvusdVGOg1r5vshFDSZSmUdIuE6PcVskva7Rh8lO75/ox9gk5TaQxAqmAnmI0zl5YFhgAmOguohCmHNYh4zvvrd3YtYPUqZz8iCoPT8dxJW7WGGxMkcvtOBBssS8HrK51jMPYzGMHljoBj53LJgehXuclUdp13ntzGMhOOGSb06vZ9y4QMuKmcWrHOPAsrNYbKTMggLp/S2WsI/D16oAAFGhRzGSxnFJ5ZTAyiLlMRIrt/FbGA/WfrIRh+WRzbF1heuXSRm9q10TZLHT2kAsdnBrv8HE9sTKfFhsB5/dUeeGsYwMvOw6Y+EzXnpvW9JoP6bP08tMiPSgcIiehXTksKGD9sMezlyA34ITKTPUuUvtjAB8+iw9jcZs2oaFeX+kDdBLPrGZTPzRIQsAwORi+16Iok5ONafBuoneQpT3nOzpF961/7fVgM930OhF7OI7Bm31H8ZCAl2fHJsMmZTJd8k9L098+3YKlqvpMj7c9EkAwFIIXS1/p3yZcIFMuM37I3CaOyY7ZSlZ10VOurdSmSTcvjiHbUZOtuhpKv1LaQwbfCqLBmjBrxpjd9E45TXJl5LGSbc1i+1MCaaB7zioQ2yxPKd7+/rfyJM9w8kgc2hYOPE4HEUs73PMS6OVTnfs52+HCAov4CG58Wmwn4rrWeV33jxHw/bYZsq1PWQIgU10D70pfL9lwxKNjuEa3dqTjlyEZjDUFLbEvszvoAKuzMpznU8fRUYSJ+XoDJUr79MMX6QP8drrWsrM+q0wTD5Eo+CUL/UFPnvLMtntR4PbYH0JAKAxfhBDdbyPfhuNakgYE6eaaXmSXW04wvO4CK4kcfHqGeIit8FDAzGWQpnpR1Mxk0XVj9NR8DGJHGfDBEMiLv0u+Om4cjo+x3DSj7jxFxvky6GHxqfhF8FFIjWB7Zi/i5Mwc5DtGxiizB0xpzA5wLHO/njuLctiLXa6OTeutdC4Wu7xIPRNJhBblmj8dF6OvwhnmZ49/xoK8hlKmr1MPbIa2Ca7ncZmMo7ydk/nI2hebujayoVorJsJt1wrk5FTzTsQGMXyvMYXabRCy5nwC09gv+Jmt8IbztDOrD+NX6eJ339ax/nT3sXFI+DMBD41zXacTZ1ct0wiVhjqWFhmYYJ1tA0lixz38UDupg7KJeErq+UCnr1rHs9dZhjr4BNchIp6JMmZZRviommtT1lCMRfB798dx5BJu5FhwYAm9iUyPAR9YVwc40o4f/oNJCGp15hQnUYwboQ8CQAobuEieXiF5C3IagYAiGy2IbCyBVYHSdZc3M3PElIhFAUFBQUfxW1l4AkTdMP65eaDmHt7oZNszlbDt4QEbSY76L5HJkZG8tExzRRYRhLZwFXJrP7YzmvPLnC10l+yYyCH7tzyVrpRGeCqVjDK1a49dByVBrKmH2jIQD8ZyFVuIVmWAM2uojGIbo3nQbZ1up3X+B2h66Ur4YpbVKjFJfluO8sY3bH1vGx8zEyWHT9D938kdxQBFzgsZZ+QW69H+a7AryyTKTWOhGGsn+EPbylZz8UxlkPtfIBr8tEVMrN8UYDRQjKmwmtkHf1gidP8IEMhWxaDEK/nfV6XpVIFd1HG12ToybD/k1jN5TM3/jPdy87XmahruIdsL2GVTGqD3wFkvcQ2f/NjzwD4TQ7gu2N2kGGS2CKWT2rGLyD+g0xAejvoLY2eJFPelcA2dJb/DDn+1KE37Ax5+CeQnQXK82GuTZFV7cnbjsUgJkh3bpHMaZnu8LkCjvfyxGuID6Jn4ZmnnnxtL706TySZ3K8eyMGnAuUZNIL6Mvgzhjn8s9iGB7y83y9bl7B/jCGUy51kpeWb1iEUAL/YyXGbjOA9n2mMxVAF549RQ3atrSOjbNjANj8w5IJFJtwjw+n6G+fNAABXIu+X4CBbHM/pQsIi41ab5LlAZ+ycK2EjDKmJwK+i8QZ1VTCih21mnkHf7WRoZqzwZ7g4znNj7k2ih1jSSTn9cJVeiCmR+mno8mJqkfLIGWI4aB3OGvZM8jvdNnrIeyIW8CuZ+CsYZts9U3zWmTC5kbAhGLpZjn9qM89Qmc77FwBA+Ktk1+feR3luXirEyYk/Y5u7qGuzCbQB6fMML52wDqMsnM/oMslNOic5R/oK6P2GlA8j9ajcSDXPawNzqEep1/j3Nn9+p/KHdhg+TnsTOH7spv1XDFxBQUHBR3FbGfjSATKakGGyHm9dI2ZKyazu2cS43vfnGCv7qDwcRpvrj6gZbkf1dDGum53Ik/iuJXPF0mWTrfv5h2BkmPG47TFkEHVdLGfbDm5bTdduxZUpxhKLNpLBa8L4HdxgDLV9rhL74v6Zzz/Ja88HMxHk2UD2YWuTCZeEMeR0smQrOm/954F3yAOAtHaWsTmW9BiqYCx+2sKcwT0HmNRs7iCrC+u6ApuDycqgG/sBAEl5jNeOn2a7rImMVwcnjmH2IhlWTShX+tRlyrq1mAysLDwYSf/GuG73PWYAQGcNY4E7csje/DwOtJ/l2CR9hsw49SAZ1/QbFgDAyP6/BwDMJnfjQjBlklVN1odHPnDLMlmMZJLHLcvU3LkVMF3kGBkGzgIAnKX0duxL9Mr69Dnw+J0DAOgLyXp0LfT4pv3oOez2kK8sN84gRfN/2jvT4LiPM70/wOAcnIP7vk/eBA/wlHhTlCjJNmXaMl32Wlm7srG9tZcrx4fEibO7tUk2Vdk4a1trR86ud2OvaIsyJVnifV8ACIIgQQIgrsE5uAbXAANgZpAPv1Zlq6JlCfuBVUj18wXn/P/db7/d/bxHv03/Lr5Laubcfn7efpP+psUF9XAeH2+aqV8/sRVrrqwbS2NPeJk8A1gsKUvI5mIxOp5dgRUxe8OMT1ir0pwcyd+wpcD09MSnlokkbbyHVRRl4hL+uRuaTONZm5Z4X9vz6H3eAimo0xNf1mwu1sqeLXz+zM9h7WHrTHqpqQAaG5iV/yGxizOjJkAXg75/181nD+zvV34sft3uJayh8GqCA1fuI6/4ofU61ohFci+ZJSZiPzGBvD9Fz6vyePevnxtSnIfA8digiXhq66eWyVvCP10VRTxmMrteC+FYIWFLjNeIuQksu42vbauTlB1PTCx0huDqvMMw3jTePTZD/KWnsUjHp78qSXrP3PkZnY0v3GGKZmVkxanxQ9h5byz9PTiI1beuFsvlwvdqdCea1MmXdjFG0z2XJEnDr7DG5DTymXu7Q0oaQZbBOlvMysLCwuL/SzxTBp5tosB55s66a3XPq+gcN754dlBMqMLDzj+WRjpP5pkpDW3Ex+yuIGMgouuSJKm8Dieifw3soDv2Q73goohSZj/+3aFH7KR3Jth9a3NLFb+G50UE2b/CG/FJOcfZGe9UnNUaLzvy5b2kwQWu40MPGzL3VJayU+d03Nb8LM9+fM1cd78MYrU+ZEqEFuKDLnTd1HQrw5LrxK899BYMKTXZFJOaz1ZULew38ZFhUcOkETpW0bfxNqyWKxNV2p5kytPugIkN3fgunz3fLUmKLFzQ+wd4x1YfDLKlAkY+1w8jTY4bkj+Ar7J6gQyDzj2w6sA4mT+FHTAfb+lmHb6JdTRwZPnlBRaiaGdZG/7T7vujuleKpRZzyNxZOATjnDBHvQ++X6rgJjIw8s3xfU8u8ZADbiO3TuR67xuN2rFENstgETqZfpIyCnLCTgMVT5Qcj36E3Ix1cT+Wyw0Hx64zHd/W3RgyCvY+4POFFbDI9Yu0N+oYulV7KlH3M7EMunCh6vgy5dK3m0yhOVMu4URzpNx7yH752SUski31+P3X5sJMW353UO3/gbZkbOB4e8wrWBB5Deicbwy/rz84JE8ijHshn3nkuGBKLG9lPuT2LyqQClNcykWeP/bwc/IgjLyoalQn69DLf/48MvthHTLc9zrvuu80hZ0WXYrPJPYU+eLTD618Eo7UkGmyMILFPhC7SduSEXDPKHI6esdkApVjFT5oknpTsXJzd2E1D5pSvW0lPCfR3Fs6tMOvn97geW2mFv1r0ejMYzf6tVqVUjGW5mwP2Uz9G7C2+qKZwxOV95Rqbt7pf8Tn3YlY1pFvsx6mlLH2fS42T93X6dfZqqfPH8vALSwsLFYonikD/1UaN3cERmArOxPWK5TP7tbZBktM/wq+3ISfGiaeN6+iELtY4DSR4/7d5FpOJ/1MkpTXSrGhwrLNajkHG/Dl46crjYD1XH/FlAa9eEWZSTC1yWv4zsPT+XxHBuzpT1oy9INI2PQ3Xfg2b4azUwfzia73jsNGf5LzUIfW8/ncS3PLlklhHoeQhrth8R5HUPMnyFP3XCGfeWAVPrJML7u8KyxDkYa5e6ZhuoOL9CXQgiWza9octtgbpi5zM0lCA366W+Hkv2cfwofnaBpTVjPMKH0JX2LOdhjTByGY+cslfiUZRqpxShAUT+ILnAphAb29nj4cPzeuhS3EHtZdhIHq07vAFRiHBb6dbJimf6fO1cOq/TEw5IYYikZlTFMkaTKjRGt6oU039hFj8S3CHu8IWWg97V3XlKiMSCw8ZzI+xo4s5Da2Cb2LvVaiYDIy2Rkgw+GRyRgqDGfM+oKPlPDkKO+KxZe6fb5IkhRqNn7YLlMSN5isxALkXevu/fTC+AdwraetL/yAflx11qjoNFkj0atg4nsnsDzvFTBXhgaDqs1lvnRcx2LdP0Pso3nC5KpX8fO6tloVJXD+4vu9WKOfi2D8F431cWfplLwjZHfUltO3dV5yur0+5sTC/VGtL+BvfWMwyLR4LKdBn8lvbmfeR4xlyr32tyRJ8Q+NXHZ+epnc9KAPByP3SJIaRxv0qJc5sSaDdjaYw2kzS1gRaZtyFDT3zN4LN0fqOznUlzCOBevZg8503p7UYhnj/h1hef6mCb1IWcJadRe16uE4elOdR0xkczJr3M8aGYfDM8P6m1lT1nYI/Y6PxlraG4W1nHgQJv7BT7YpaQvWyLcLnl7M6pku4LETpOZELTCI1z19ChvGrDl+mIEe7aFJU7GYzxMaV+3b3A7znxNRgi/cxzzzb+yWJDX1MfBJYX2q2IIAz82jyEc2Mplf9BC0GDpaqlW/JmDVkIlAc7oJhPkWUNYnh9Ypf5yAX30Pi+etcBaTUnNWZymRNuxzlqhhiP4EtrYuWyZDw0yerF4UKbU5Rx+eZNCqPossXnpIe6/VYtb2NHjk6TFJ/6swjzdeI2g1X8vi0utmMYsanNNWB5N8vIs2b3Oi4F4PCn7NF67AatxTeabOib+fdr0wTIcfJpSrutakMToJJMa8w6YRjGADO3SbcWhJdSo7h01otBbZHlzGNVlJs5ihrkUU+2zeExV/h8V44g9xZXXsxC3iu0VANWv/lNyJuEUWHmCijobYhI+VsVh/9I5JYavOUacxV8PrLkmSFkNsbrF+ZLQ9wy/PY+T/tzsY32NtZhMx1Q67pir0R0lsjr8YRJaXOnDtbNxj3BYVkBZX42eVWkKwr7nvn1YL5fLbbAC9i2ykrpBHYQ4Ok/gK0I22J7gLqvwE5LPcGfIcZNwCQ5CQ8SsEKue+SD++0Mn/Nhj2vmEAABNoSURBVGe0KHcEeR56gD4WmkB/Zys62DO3qK8l4IK5M8Ac8QUY64hM5Dz17iptPUhb+xvZbHJC6EyJj+enZbMo9vhDSpigVovXbDD6xqeXyde2sFD2DNCn3bdeVXseC23sBOMfVk4/w8xtRQNtbs1HsyFV+yGHT8qZI2U70f/q9xjzYme4PEESIB4UGBdYKptbviCbww+kyhfYXCffY3F/WAERer6Ad19LPaHvDEDAHtcYUulEtpeWkN/z1yGLyaGLyh5jFzt/mOe++I/037pQLCwsLFYonikDX1+KCdNwhp2nZ2Oi3kiESXUNm1rFbTDygip297SsRF0rgNluCcMtshgNQ1t3iYz/ji0cNhlM3KCRFthGpzF7fz3H8/J2krCfdP+R3vfAKkvcvPPKl/lbWQOpeY5bA3Ksxn0RzIOppTeYetmj7OLBXNin98laZe1mh249t/waF/0j7L5395FiVN3iUWUJLDDlIkzyr1P4uaoR83a/b0YdiZiFb2ffkCTlHOVSVtdH3NSzlEIQcig/Q3PnYK/+dljU0h7YxpIDayVy1VpFpSPjQDqBqMc+GH5nIUwibqxHk+f4Ps1B+G06E9eJqwxm5/TDLBZmwxVzmnHdnEnZBC3j0ErCKtq59Szj5DqUorY3CR7H74ZlFzkJJEaZ6oFjj2OkJViwcxtjf2QQftLfhHXhKzbBrHtdqqiFyS9mwj57o0nHy7jwPyRJd+dfUIkLK/C1JhjnZZOe9uJ2GNj6hg41mZINZfEwwYwF9KR5AJ3InEKedd7rqm7cI0mqTOv79ML4B/jGCG1uN+x1sm9QTh+6Mf5nmPOxu7De2uOwilIm/kK3uxiLHcYVebIcazT1TXTv1G76kPigULemYfQR+Rwg2TSL/vdmIOdVN3fp6l7G4nEKc+C7LVghf27ug8xPqNPNtfzPeifzuNNF+mDwF7w73tSijxk7r8JK9Pqm+yPT03+Mb/6/GPczbo4gAcLh59q0qhg9PPWIMSgZgdkO3GI88/KT5avk+xvDWIi/M4+Mhgf5vfshbtax3xtR9Q1YcK9x6e3NYa4+/pA5GOaN0dYnWLznHehc0l8xDqe/RgpiXMdl/XFRkSTpW3O4aSp6WX4HY3Ez9jr4GuPM03AGFsDs902NjRc+uf+WgVtYWFisUDxTBv5nIkXnha+zu3xrZEBtV9n9s0r53RoXbGdoiV15YuG0Ui/BWII5MBBHPiy4fbW5VftD/FlRL7lVtxlf4Bth7LrDfeyas/+KdK+Y3/LquSL8k78pZNfMHoS9ROfAFuZvpqtIBMnq8vhcaQSBoKGrfHZ+H59JnqtTxvuwinXdry1bJoFsGEDA3MrRNL5H/zIEm7hQAaMMKyfo8aCPQFteZJaiGmF6L4vfJbVy49DgAsHN2G725phgUGf/GfLJmzQHUx4j6+AoLGgiNkqVfm4vKTD3lUbGEpAa6GI8nPm12heNf9AX4Gaa0XmYzoNbqFFkOgw9ar5CvbHIJNpLoGzzMmRSfx5f6lINDKc1PkmZ9ymnUOMmvcpfQ5B05jo+xr419RrzYzV89QxfW4vNgZkKgmzBHNLVMvZk6tRlLLNtU/ioG0r/myTpGwv4HltuDyp2I892LzHma3OwsC6/SZ+88feVfYT/XzsEKzOqqLApTI6h9RzGWttVrmtFsKl1l0qXIY3/i8nINyVJxc3/nj7vcutJBzrXn8B7vlyCD/a90R/SL1eGUqPx3Y/3m7r1n8Nf7I1gPnld6PJs52+0eQYr2ZeAfKfnYIVJOVh6wXKfCqNof04Dz/1wh6mAeAn5tO06oOnZ/yVJarmKjh0s5xDehT20IfwCVkz83pf0l5eIG+xKevqhlU9CoQlqN3URq6qIH1NWM2MRbi6DCpo7J6uq0Ctf/JIyl7As8kxxrb+7iPVdFcLS2HWI+T73ywldXYd1NXGOPvgWsFziNhM38fjaNGhqfM+0I4uybbzcEYY//srwXQUmkHfyPub68Xr6O3LAWIg+juF7M24p9hGxg6VtT9cVy8AtLCwsViieKQN/aQafrusWvsRQQUiePeyAqxzsfI3nTHQ4C/9sW1+eSo7CwD1zHBhJuwNrD27lf26uYpfaXzaqbfOUeXWbO+Vay9kZ0/4NvsK0iXx9WAODz3+XXXimxpQo3Qyb7X1YpNFo2Hl0Du3rj+RrsgP/an876YSO7CZND7PDZ3yzadkyqTZHZqdzYD6fnXmoN+fMgach3llwAyY+vQWW0dsaUH0xO31OmLltJhuLZXKQvqQ8R1ZKSSBdYR9xXHxqjl193m1ub9+ETKq93Urp6eZvFbCoB/PIr6gEpjQTbNDVVFhFwdvIv/YN/Jp95zkUkehDfoNhs3KFyCCZmP30/syPMZpPSl5wnsMoye3Fyq8kU8GdhzWS7YIN9cfD3hbzorUlk/rwLh/sd6qd2Eh6N/7IqEZY1mzEZ1RmCi/dbUb+e3OxDueHOMa/ZfqeTplMKH8rsiwL8LeDq+E9dduPaqTelHgVls90Ktk7+aZ076OzPGMpfkzrx/ldaphr2TKRJHcYJSTaY8yhq8epSig1pVzNEe4/j+TriTjYXfyTx5p0mPsV15BZ0n8aSyl9ktiFKxxmeOHVvZrqQX+WkjkA19COXh4sgTnX1ZcpGfewMt38b1MN+h9IoSyEc+SKqud4//SS0e/3sWIcpehysA1mOhDyaVUhbPeuN2HZMplvxUJIriEeMzcZpvEOUvBip2Hiu2dZWx5s54BYw+Vv6ksfop8Lf8z8OTbC2J5+zNxrNNls5etjtWUAWUwGmPOrd1+SJHW30e/0uWo9XoNV9pqIwX2wh5/33yTT7fMv7VSDF9/35QUOL45vZhwLOtC9HV50pfeAV2WmdntfbspT+28ZuIWFhcUKxTNl4E0fwQC/eBgm3XkxRn7hg7xjilqlJFCMqauRCwrSalwaucfOVJ/Bbtm3hgwRednlj54wR6dPjWsoBGNM64MRpazGD9o7xW43cy9eARMh798M248PsNtFTnE7/cTUFaUdxnfumSIH/ckYOZ+laex5JZvY+X3/NVb5VbzD409atkwSYsgIKb7+8RF2KWIVu/jXW/Ax973Eu2fqYbrnwwM6OMBuPug3t3iUk0XirSRTJ7kCv93D63WqOoj/8kEnmSoL6fiyn3fACBdbo+XPob/uLPy+6Y9gV3HmliFH5LxCo3v42xoORd2a4aKEkdVE2oMfMD6Vx+4qrYK2//1417JlEpnOxR2p8WSj1DjuqjkX+aS9Yw6W1DDO5ZuwJjZMZOln9zknEOZFpoXbzZHnJNhQ9i8p51r8nbc1NoEfuagSJn67mee4+slcOPuKV4efEJ/oOUIKgE8w+MkzMLGE8Bn97xCZGMdNqd/SYdhefh6+aO2HDca4f6nWQdq1s+TKsmUiSdfLGbfKAqbt6PiE5l2MT9YC4z3mIdf4nSwsE39PkbSV+dLbBfMOVpqj3EN7JEmhdcQrqv8uKG3j8/mNWD+PK7HSGq/9O0nSyIHzSq5j3pz5KtZQ+kms3CTjw3bFzuihj+8XIplbzrRW03dTsOkQczrR51D/Tdj9lvSPi3wtA1H0+6Y5Lr85KV+uCCym10xmUXvOH0mS1s9T4yI56ftqPk77spvQ86vJtCfyKOO5oZkCW0mhIl1oJYaSvwCDny1k/Ro4TL8j3/JoKgf9PFeEfu6NwvcvJz9Hdc5p05fMzUh/wxx9FIeMN6zDN98c+xNJ0pjjvyhyA3GKjNDkU7tvGbiFhYXFCsUzZeCHXyd6O1YPO47aVK+acb5vbYTNVa+DLTV72RnrR57oe4nspKWLZD+4W/FXTZWzc7/732EbeWllis6AkVYM/1ySdDKEf+1AL37yqV3vKW4QJto1CJNIzcZP52+g9ON8fIHiTvG5g7vw60W58DkPdMMock7hr7vzn1K1/wksM/xB4rJlEuc3u/huGMFMVK50h/78IIrdt+whVknuIIxnqDpTQ00whdAJGFjECNk3Xzlp7tb0curwF2uKtbWTv3XdxX//agRs8VeVRZKkop2nlXSd3PqCSvzag+/CIF3HGAfnYoxmw/6jJKmuiPbsKiCGoFF8z8GDMNOl4H7dLMDHuCEyfdky2RnOuLQ4kKs/dqOUBEuZPEb/vCOw0VAIVrvN16HK3fi8c4dpc3gPY9cX4Lj7ruOwy5Pn51Ra/D1J0ht30JdADCy7uRomVTz/b/XuXth0+kPiCwv5ZDw0B7DgEgpnte8eFktLPr7wkjjiO1NL6Im7H9/s3tGj8qTBgLv8H5dNXR5evEf//F5yejrC1+hgADm0j6NHZQNYRw8qmWuJ+50Ku8x4RcfBICf6aGtMGpaZ44f0r393u8LvksHT4TEMsJR5kBHzU0lS1t2A+ubRp7lfMf9yTzB/HG6YfdegR0FzXVuDucv081/COrryyFicXcinObioiBB6XTcRWrZMIlJg3r83xVjdSAwo0lx3+KQYZ33oF4ztcBRrTFruAUWUY3lF9rHexPRxlL46ZG6K95IRsmaxQY2vmXk4hdymHcw9XWYc41+p0nO3+Vt2EutMi7njNiyZMYtPz1XmX+P/H38R6znbj06XXIRHj+8j820s/KyGuillUfMAa0KvfnIi+DNdwDcHUO6xjZgSWd3ZOm9uLPGnMIiD4XQqYjO//4PpRZ0/jZKGFyLI4SKE/EUni+gPanBnhC57NG8OBNVl85zP3mEyay3CmQqL1/1sgphZaQh5JByBxvYxaB2x9SqIZXG6tcgEz2tg8Lu9pFeVpnVLknZd7tdUD4oSv/npdQs+CffDOXBR8YAbbKIP1upstDmAMsRkLFpkIapfRzDqhfFINa82R5JvckR50mXqK+8yh4ASWPxKosLUeo1DGZ/JQimyu5BNVSKLa8JAnvLMkewbDYxD1QFTs91HWxpq5rRtFuW8/5jF/cwHTJTi40zyVA8ycc8PK6OLTbZ0it9pGRmWPQukbubfZRPyr5tT7a/o+6IDvZjJYCGYvs1x6aH0VBU1sPj8Mp9xrRSTO81LIGiuk0Xu1a4yNcXyvL/COlZ8FgGvuGnGMH2wUN1xPPt3wglovb9gar+Y/sY99KpvA8/Jus9Y5bpxHXVEcYHty9Wk/t2JOqrNLaaq5tHlX94rSX+fzVi8uMQ7x+eG9aMR5sDRcVwUi2sYf8d5+uxaf1aRC/Sjs9gE3c4wtp6XWbz8202/LriUEXdSkhTpfV2S9KidNrfl0+a4/lsqMJckv+5FDy6a2iCuUZaTdSNTqkvjmaXVtNl5lcUrrZ8xOReFvOKSZ5QSy4ZQ0vZxPf1Pryy+ILr8aIspi9H3c829RUpsykYIS2IR//t+PIt8dWK8Ct5DfxbLSDyoKeyWJEX3I9ulaUhEZ26nnltEfgN/y9rS/nUeuC2FtWBu/JJ61zIX5mbMvQHJkKTUWUhNqa9XnTtYt3KuM2Z9OejytBOXYVEaFQyXkorl9JoaRyd2PbX/1oViYWFhsULxTBn4Tx7BwEtHcZv8uDZPXzI33SyaKmqPU2E3rlYCYj+afkfOGA5L7J6DYU1GEnD4qB9GccRlTFs5FVeE6ZYas0eSNDaFufPYg0ulfWa1Dr0Ok2y4RipTdoA2RPZgYvv3vaGY26YeeSeugIgYGHmcl8+kmHjlOVehFgMwxqiup6f8fBL66zBDI46w8098IEV/nb9lXUBePj8un2IIgIa8P5V/mt0/jI1aV4/g+ngujgMcQz0EYSImEtVTg4ujY4SDSo6LPOgPd8K6b0Zs1PubkGGCGwa+tY3+1h8icBfePqt9WzHLL3fR1pzfx/IJu4sJ7kkg6Bhd7dCC2xR82rL8wNRIUpEkKf4zVNhz3Tuqd6MxV6vMPYLhQzDd0TiCjpEFj5Tl5DbS7dtgf55I2hkfMjetBzBnr6R8RfsK30IW97i56C8DjPcO426KX8rSy02M618gaq11w9pW3TN3u8bPy9UHk8xogVkO7IblhaWiY33zWIB94Qmay6FfztGYZctEkna6OfCxsIDcV3VLZz+PXDrvkop29iIpo9/K4NDSbdd6LaaaO0w7cPFtL4dNF4URpG1LwGVX8S/WquB/4kprMXfKhpOtqbBRc9NVZa1uuGHuo+W801HPGHQGsVa9IyW6nc3S8ts/Yo4G9/Oupu1YVWv70I+F4Q7F7cadMTsStmyZRC/CXreYWvQdMbXq/TYWRnwsAeR0k1r8ry+xFrRHbNLIAdh5tO+3JUlHJ7olSd2prAVJ4TDo0ymHddhp6p0fIxh82ourx2lKSBQPbtSWA1hAjh/Th/pJdGQiHp2byZtQxyZKGeQ60Y3aQaw+53aTlNH3B8im4ZSSD/H+sW5qwOu5L3xi/y0Dt7CwsFihCFsy9Z8tLCwsLFYWLAO3sLCwWKGwC7iFhYXFCoVdwC0sLCxWKOwCbmFhYbFCYRdwCwsLixUKu4BbWFhYrFDYBdzCwsJihcIu4BYWFhYrFHYBt7CwsFihsAu4hYWFxQqFXcAtLCwsVijsAm5hYWGxQmEXcAsLC4sVCruAW1hYWKxQ2AXcwsLCYoXCLuAWFhYWKxR2AbewsLBYobALuIWFhcUKhV3ALSwsLFYo7AJuYWFhsUJhF3ALCwuLFQq7gFtYWFisUNgF3MLCwmKF4v8AZbRes8Q6lrMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
